[Meting]
[Music server="netease" id="486856842" type="playlist"/]
[/Meting]

python基础知识二

基础数据类型

数字 (int)

v = 11
data = v.bit_length()   #当十进制用二进制表示时,最少使用的位数
print(data)

运行结果

4

布尔值 ()bool

布尔值就两种:True,False。就是反应条件的正确与否。

真   1   True。

假   0   False。

字符串 str

字符串的索引与切片

a = 'ABCDEFGHIJK'
print(a[0])
print(a[3])
print(a[5])
print(a[7])

a = 'ABCDEFGHIJK'
print(a[0:3])
print(a[2:5])
print(a[0:]) #默认到最后
print(a[0:-1]) # -1 是列表中最后一个元素的索引,但是要满足顾头不顾腚的原则,所以取不到K元素
print(a[0:5:2]) #加步长
print(a[5:0:-2]) #反向加步长

运行结果

A
D
F
H
ABC
CDE
ABCDEFGHIJK
ABCDEFGHIJ
ACE
FDB

字符串常用方法

words = "beautiful is better than ugly."
print(words.capitalize())   #首字母大写
print(words.swapcase())     #大小写翻转
print(words.title())        #每个单词的首字母大写



# 内容居中,总长度,空白处填充
a = "test"
ret = a.center(20,"*")
print(ret)


# 数字符串中的元素出现的个数
ret = words.count("e",0,30)
print(ret)
a = "aisdjioadoiqwd12313assdj"



# startswith 判断是否以...开头
# endswith 判断是否以...结尾
print(a.startswith("a"))
print(a.endswith("j"))
print(a.startswith('sdj',2,5))
print(a.endswith('ado',7,10))


# 寻找字符串中的元素是否存在
print(a.find('sdj',1,10))   # 返回的找到的元素的索引,如果找不到返回-1
print(a.index('sdj',1,10))  # 返回的找到的元素的索引,找不到报错。


# split 以什么分割,最终形成一个列表此列表不含有这个分割的元素。
ret = words.split(' ')
print(ret)
ret = words.rsplit(' ',2)
print(ret)


# format的三种玩法 格式化输出
print('{} {} {}'.format('aaron',18,'teacher'))
print('{1} {0} {1}'.format('aaron',18,'teacher'))
print('{name} {age} {job}'.format(job='teacher',name='aaron',age=18))


# strip
a = '****asdasdasd********'
print(a.strip('*'))
print(a.lstrip('*'))
print(a.rstrip('*'))


# replace
print(words.replace('e','a',2))
print(words.isalnum()) #字符串由字母或数字组成
print(words.isalpha()) #字符串只由字母组成
print(words.isdigit()) #字符串只由数字组成

元祖 tuple

元组被称为只读列表,即数据可以被查询,但不能被修改。

列表 list

列表相比于字符串,不仅可以储存不同的数据类型,而且可以储存大量数据,32 位 python 的限制是 536870912 个元素,64 位 python 的限制是 1152921504606846975 个元素。而且列表是有序的,有索引值,可切片,方便取值。

li = [1,'a',2,'d',4]
li.insert(0,22)     # 按照索引去增加
print(li)
li.append('ddd')    # 增加到最后
print(li)
li.extend(['q,a,w'])    # 迭代的去增
print(li)
li.extend(['q,a,w','das'])    # 迭代的去增
print(li)

运行结果

[22, 1, 'a', 2, 'd', 4]
[22, 1, 'a', 2, 'd', 4, 'ddd']
[22, 1, 'a', 2, 'd', 4, 'ddd', 'q,a,w']
[22, 1, 'a', 2, 'd', 4, 'ddd', 'q,a,w', 'q,a,w', 'das']

li = [1,'a',2,'d',4,5,'f']
a = li.pop(1)  # 按照位置去删除,有返回值
print(a)
del li[1:3]     # 按照位置去删除,也可切片删除没有返回值。
print(li)
li.remove('f')
print(li)
li.clear()
print(li)

运行结果

a
[1, 4, 5, 'f']
[1, 4, 5]
[]

li = [1,'a',2,'d',4,5,'f']
li[1] = 'aaa'
print(li)
li[2:3] = [3,'e']
print (li)

运行结果

[1, 'aaa', 2, 'd', 4, 5, 'f']
[1, 'aaa', 3, 'e', 'd', 4, 5, 'f']

切片去查,或者循环去查。

其他操作

li = [1,2,4,5,4,2,4]
print (li.count(4))     # 统计某个元素在列表中出现的次数
print (li.index(2))     # 用于从列表中找出某个值第一个匹配项的索引位置
li.sort()               # 用于在原位置对列表进行排序
print (li)
li.reverse()            # 将列表中的元素反向存放
print (li)

运行结果

3
1
[1, 2, 2, 4, 4, 4, 5]
[5, 4, 4, 4, 2, 2, 1]

字典dict

字典是python中唯一的映射类型,采用键值对(key-value)的形式存储数据。python对key进行哈希函数运算,根据计算的结果决定value的存储地址,所以字典是无序存储的,且key必须是可哈希的。可哈希表示key必须是不可变类型,如:数字、字符串、元组。

dic = {"age":18, "name":"aaron"}

dic['li'] = ["a","b","c"]
print(dic)

dic.setdefault('k','v')
# 在字典中添加键值对,如果只有键那对应的值是none,但是如果原字典中存在设置的键值对,则他不会更改或者覆盖。
print(dic)

dic.setdefault('k','v1')
print(dic)

dic = {"age":18, "name":"aaron"}

dic_pop = dic.pop('age')
# pop根据key删除键值对,并返回对应的值,如果没有key则返回默认返回值
print(dic_pop)

dic_pop = dic.pop('sex','查无此项')
print(dic_pop)

dic['age'] = 18
print(dic)

del dic['name']
print(dic)

dic['name'] = 'demo'
dic_pop = dic.popitem()
# 随机删除字典中的某个键值对,将删除的键值对以元祖的形式返回
print(dic_pop)

dic_clear = dic.clear()
# 清空字典
print(dic,dic_clear)

dic = {"age":18, "name":"aaron", 'sex':'male'}
dic2 = {"age":30, "name":'demo'}

dic2.update(dic)
# 将dic所有的键值对覆盖添加(相同的覆盖,没有的添加)到dic2中
print(dic2)

dic2['age'] = 30
print(dic2)

dic = {"age":18, "name":"aaron", 'sex':'male'}

value = dic['name']
# 没有会报错
print(value)

value = dic.get('abc','查无此项')
print(value)

其他操作

dic = {"age":18, "name":"aaron", 'sex':'male'}

for i in dic.items():
    # 将键和值作为元祖列出
    print(i)

for key,value in dic.items():
    print(key,value)

for i in dic:
    # 只是迭代键
    print(i)

keys = dic.keys()
print(keys,type(keys))

value = dic.values()
print(value,type(value))

集合set

集合是无序的,不重复的数据集合,它里面的元素是可哈希的(不可变类型),但是集合本身是不可哈希(所以集合做不了字典的键)的。以下是集合最重要的两点:

  • 去重,把一个列表变成集合,就自动去重了。
  • 关系测试,测试两组数据之前的交集、差集、并集等关系。

创建集合

set1 = set({1,2,'barry'})
set2 = {1,2,'barry'}

print(set1,set2)

集合的增

set1 = {'abc','def',123,'asdas'}

set1.add('qwer')
print(set1)

set1.update('A')
#update:迭代着增加
print(set1)

set1.update('哈哈哈')
print(set1)

set1.update([1,2,3])
print(set1)

集合的删

set1 = {'abc','def',123,'asdas'}

set1.remove('abc')
print(set1)

set1.pop()
# 随机删除一个数
print(set1)

set1.clear()
# 清空合集
print(set1)

del set1
# 删除合集
print(set1)

集合的其他操作

交集(&  或者 intersection)
set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}

print(set1 & set2)

print(set1.intersection(set2))

# 列出两个集合中共同拥有的项

并集(| 或者 union)

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}

print(set1 | set2)

print(set2.union(set1))

# 列出两个集合中所有的项

差集(- 或者 difference)

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}

print(set1 - set2)

print(set1.difference(set2))

# 在set1中删除set2中有的项

反交集 (^ 或者 symmetric_difference)

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}

print(set1 ^ set2)

print(set1.symmetric_difference(set2))

# 显示set1和set2不共存的项

子集与超集

set1 = {1,2,3}
set2 = {1,2,3,4,5,6}

print(set1 < set2)
print(set1.issubset(set2))  # 这两个相同,都是说明set1是set2子集。

print(set2 > set1)
print(set2.issuperset(set1))  # 这两个相同,都是说明set2是set1超集

frozenset不可变集合,让集合变成不可变类型

set1 = {1,2,3,4,5,6}

s = frozenset(set1)
print(s,type(s))

s.add(7) # 不可以修改,会报错

基础数据类型的总结

按存储空间的占用分(从低到高)

  1. 数字
  2. 字符串
  3. 集合:无序,即无序存索引相关信息
  4. 元组:有序,需要存索引相关信息,不可变
  5. 列表:有序,需要存索引相关信息,可变,需要处理数据的增删改
  6. 字典:无序,需要存key与value映射的相关信息,可变,需要处理数据的增删改

按存值个数区分

标量/原子类型数字,字符串
容器类型列表,元组,字典

按可变不可变区分

可变列表,字典
不可变数字,字符串,元组,布尔值

按访问顺序区分

直接访问数字
顺序访问(序列类型)字符串,列表,元组
key值访问(映射类型)字典

其他(for,enumerate,range)

for循环:用户按照顺序循环可迭代对象的内容。

s = '先帝创业未半而中道崩殂,今天下三分,益州疲弊,此诚危急存亡之秋也。'

for i in s:
    print(i)

li = ['甲','乙','丙','丁']
for i in li:
    print(i)

dic = {'a':1,'b':2,'c':3}
for k,v in dic.items():
    print(k,v)

enumerate:枚举,对于一个可迭代的(iterable)/可遍历的对象(如列表、字符串),enumerate将其组成一个索引序列,利用它可以同时获得索引和值。

li = ['甲','乙','丙','丁']
for i in li:
    print(i)

for i in enumerate(li):
    print(i)

for index,value in enumerate(li):
    print(index,value)

for index,value in enumerate(li,100): #从哪个数字开始索引
    print(index,value)

range:指定范围,生成指定数字。

for i in range(1,10):
    print(i)

for i in range(1,10,2):  # 步长
    print(i)

for i in range(10,1,-2): # 反向步长
    print(i)
Last modification:December 8th, 2019 at 03:57 pm
如果觉得我的文章对你有用,可以打赏一瓶汽水钱嗷~