基础数据类型

数字 (int)

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

Python
Copy
运行结果

4

Python
Copy

布尔值 ()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]) #反向加步长

Python
Copy
运行结果

A
D
F
H
ABC
CDE
ABCDEFGHIJK
ABCDEFGHIJ
ACE
FDB

Python
Copy

字符串常用方法

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()) #字符串只由数字组成

Python
Copy

元祖 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)

Python
Copy
运行结果

[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']

Python
Copy

删

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)

Python
Copy
运行结果

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

Python
Copy

改

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

Python
Copy
运行结果

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

Python
Copy

查

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

其他操作

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

Python
Copy
运行结果

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

Python
Copy

字典 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)

Python
Copy

删

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)

Python
Copy

改

dic = {"age":18, "name":"aaron", 'sex':'male'}
dic2 = {"age":30, "name":'demo'}
dic2.update(dic)
# 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中
print(dic2)
dic2['age'] = 30
print(dic2)

Python
Copy

查

dic = {"age":18, "name":"aaron", 'sex':'male'}
value = dic['name']
# 没有会报错
print(value)
value = dic.get('abc','查无此项')
print(value)

Python
Copy

其他操作

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))

Python
Copy

集合 set

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

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

创建集合

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

Python
Copy

集合的增

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)

Python
Copy

集合的删

set1 = {'abc','def',123,'asdas'}
set1.remove('abc')
print(set1)
set1.pop()
# 随机删除一个数
print(set1)
set1.clear()
# 清空合集
print(set1)
del set1
# 删除合集
print(set1)

Python
Copy

集合的其他操作

交集（& 或者 intersection）

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
print(set1 & set2)
print(set1.intersection(set2))
# 列出两个集合中共同拥有的项

Python
Copy

并集（| 或者 union）

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
print(set1 | set2)
print(set2.union(set1))
# 列出两个集合中所有的项

Python
Copy

差集（- 或者 difference）

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
print(set1 - set2)
print(set1.difference(set2))
# 在set1中删除set2中有的项

Python
Copy

反交集 （^ 或者 symmetric_difference）

set1 = {1,2,3,4,5}
set2 = {3,4,5,6,7}
print(set1 ^ set2)
print(set1.symmetric_difference(set2))
# 显示set1和set2不共存的项

Python
Copy

子集与超集

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超集

Python
Copy

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

set1 = {1,2,3,4,5,6}
s = frozenset(set1)
print(s,type(s))
s.add(7) # 不可以修改,会报错

Python
Copy

基础数据类型的总结

按存储空间的占用分（从低到高）

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

按存值个数区分

按可变不可变区分

按访问顺序区分

其他（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)

Python
Copy
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)

Python
Copy
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)