基础数据类型
一、数字int
数字主要是用于计算用的，使用方法并不是很多，就记住一种就可以：
#bit_length() 当十进制用二进制表示时，最少使用的位数 v = 11 data = v.bit_length() print(data)
二、字符str
1.索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。
2.切片就是通过索引（索引：索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。
a = 'ABCDEFGHIJK' print(a[0:3]) print(a[2:5]) print(a[0:]) #默认到最后 print(a[0:-1]) #-1就是最后一个 print(a[0:5:2]) #加步长 print(a[5:0:-2]) #反向加步长
3.字符串的常用方法
#captalize,swapcase,title
print(name.capitalize()) #首字母大写
print(name.swapcase()) #大小写翻转
msg='egon say hi'
print(msg.title()) #每个单词的首字母大写
# 内同居中，总长度，空白处填充
ret2 = a1.center(20,"*")
print(ret2)
#数字符串中的元素出现的个数。
# ret3 = a1.count("a",0,4) # 可切片
# print(ret3)
a2 = "hqw\t"
#\t前面的补全
# 默认将一个tab键变成8个空格，如果tab前面的字符长度不足8个，则补全8个，如果tab键前面的字符长度超过8个不足16个则补全16个，以此类推每次补全8个。
ret4 = a2.expandtabs()
print(ret4)
a4 = "dkfjdkfasf54"
#startswith 判断是否以...开头
#endswith 判断是否以...结尾
# ret4 = a4.endswith('jdk',3,6) # 顾头不顾腚
# print(ret4) # 返回的是布尔值
# ret5 = a4.startswith("kfj",1,4)
# print(ret5)
#寻找字符串中的元素是否存在
# ret6 = a4.find("fjdk",1,6)
# print(ret6) # 返回的找到的元素的索引，如果找不到返回-1
# ret61 = a4.index("fjdk",4,6)
# print(ret61) # 返回的找到的元素的索引，找不到报错。
#split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
# ret9 = 'title,Tilte,atre,'.split('t')
# print(ret9)
# ret91 = 'title,Tilte,atre,'.rsplit('t',1)
# print(ret91)
#format的三种玩法 格式化输出
res='{} {} {}'.format('egon',18,'male')
res='{1} {0} {1}'.format('egon',18,'male')
res='{name} {age} {sex}'.format(sex='male',name='egon',age=18)
#strip
name='*egon**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))
#replace
name='alex say :i have one tesla,my name is alex'
print(name.replace('alex','SB',1))
#####is系列
name='jinxin123'
print(name.isalnum()) #字符串由字母或数字组成
print(name.isalpha()) #字符串只由字母组成
print(name.isdigit()) #字符串只由数字组成
#公共方法
公共方法：
s = 'aasfhfsaflf'
len() #总个数
print(len(s))
count #计算某些元素出现的个数,可切片
c1 = s.count('f')
print(c1)
三、bool值
布尔值就两种：True，False。就是反应条件的正确与否。
真 1 True。
假 0 False。
四、列表list
列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：
li = [‘alex’,123,Ture,(1,2,3,’wusir’),[1,2,3,’小明’,],{‘name’:’alex’}]
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
1.增
li = [1,'a','b',2,3,'a']
li.insert(0,55) #按照索引去增加
print(li)
li.append('aaa') #增加到最后
li.append([1,2,3]) #增加到最后
print(li)
li.extend(['q,a,w']) #迭代的去增
li.extend(['q,a,w','aaa'])
li.extend('a')
li.extend('abc')
li.extend('a,b,c')
print(li)
2.删
l1 = ['wusir', True, 'alex', 'laonanhai', 'ritian', 'taibai']
#pop 按照索引去删除, 有返回值
ret = l1.pop(0)
print(ret)
print(l1)
#remove 按照元素删除
l1.remove('alex')
print(l1)
#clear 清空列表
l1.clear()
print(l1)
# del
#1，在内存级别删除列表
del l1
print(l1)
#2，按照索引删除。
del l1[2]
print(l1)
#3，切片删除+步长。
del l1[:-1]
print(l1)
3. 改
#1，按照索引去改。 l1[0] = '肖锋' print(l1) l1[-1] = '男神' print(l1) #2，按照切片去改,先将切片的区域内的内容全部删除，在迭代着添加内容。 l1[:3] = '范德萨发给ghfkhgh;' l1[:3] = [1111, 2222, 3333, 4444] print(l1)
4.查
# 按照索引切片去查 #for循环 # for i in l1: # print(i)
5.公共方法
len 个数
cou = len(l1)
print(cou)
count 元素个数
print(l1.count('taibai'))
index 通过元素找索引
print(l1.index('alex', 3))
l2 = [1, 3, 5, 9, 7, 6, 2, 4]
sort 从小到大，正序排序
l2.sort()
print(l2)
sort 从大到小，倒序排序
l2.sort(reverse=True)
print(l2)
翻转 reverse
l2.reverse()
print(l2)
列表的嵌套
l1 = ['wusir', 'alex', [99, ' taibai', '98'], 21]
# 1, 将wusir变成全部的大写。
# l1[0] = 'WUSIR'
# print(l1)
# print(l1[0].upper())
# l1[0] = l1[0].upper()
# print(l1)
# 2，将‘taibai'变成首字母大写，其他字母小写，放回原处。
# print(l1[2])
# l2 = l1[2]
# l2[1] = l2[1].strip().capitalize()
# l1[2][1] = l1[2][1].strip().capitalize()
# print(l1)
# l1[2].append('舒淇')
# print(l1)
# 3，用数字的相加将99 变成 字符串的 '100'.
# l1[2][0] = str(l1[2][0] + 1)
# print(l1)
# 4，字符串的'98' 变成数字的100.
# l1[2][2] = int(l1[2][2]) + 2
# print(l1)
在循环一个列表时，最好不要改变列表的大小，会影响你的最终结果。
l1 = [111, 222, 333, 444, 555, ]
del l1[1::2]
print(l1)
# 倒着删除。
for index in range(len(l1)-1, -1, -1):
if index % 2 == 1:
del l1[index]
print(l1)
五、字典dict
字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。可哈希表示key必须是不可变类型，如：数字、字符串、元组。
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
1.增
dic = {'name': '老男孩', 'age': 56, 'hobby': 'women'}
dic['sex'] = 'LaddyBoy'
dic['name'] = 'Alex' 有则覆盖，没有就添加
dic.setdefault('sex')
dic.setdefault('sex', 'Laddyboy') 有则不变，无则添加。
dic.setdefault('name', 'alex')
print(dic)
2.删
print(dic.pop('age')) # 有返回值，返回的是键对应的值
print(dic.pop('age1', '没有此键...'))
print(dic)
dic.clear() 清空字典
print(dic)
print(dic.popitem()) # 随机删除，有返回值，返回值为元组，里面是删除的键值对。
print(dic)
del
1，删除整个字典
del dic
2，按照键删除键值对
del dic['name']
print(dic)
3.改
1, dic['name'] = 'Alex' 有则覆盖，没有就添加
update 两个字典的更新
dic = {"name": "jin", "age": 18, "sex": "male"}
dic2 = {"name": "alex", "weight": 75}
dic2.update(dic) # 将dic里面的所有键值对 覆盖添加到dic2中，dic不变
print(dic) # {'name': 'jin', 'age': 18, 'sex': 'male'}
print(dic2) # {'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}
4.查
1,dic['name']
print(dic['name1'])
2,dic.get('name')
print(dic.get('name'))
print(dic.get('name1'))
print(dic.get('name1', 'sb没有此键'))
#for循环查询
dic.keys(), dic.values(), dic.items() #类似于list但不是list的类型。
print(dic.keys(),type(dic.keys()))
for key in dic.keys():
print(key)
l_key = list(dic.keys())
print(l_key)
for value in dic.values():
print(value)
l_value = list(dic.values())
print(l_value)
print(dic.items())
字典的嵌套
# dic = {
# 'name_list': ['碗蓉', '俊俊', '爽妹'],
# 'status': None,
# 'personal_msg': {
# 'name': '反面教材',
# 'age': 25,
# 'hobby_list': ['抽烟', '喝酒', '烫头'],
# }
# }
# 1,给dic添加一个键值对，学校：老男孩
# dic['学校'] = '老男孩'
# print(dic)
# 2，将status对应的值改成True
# dic['status'] = True
# print(dic)
# 3，给name_list对应的列表追加一个元素：平平
# print(dic['name_list'])
# dic['name_list'].append('平平')
# print(dic)
# 4，给personal_msg对应的字典添加一个键值对sex：男
# dic2 = dic['personal_msg']
# dic2['sex'] = '男'
# print(dic)
# dic['personal_msg']['sex'] = '男'
# print(dic)
# 5，将hobby_list 对应的列表中的烫头改成唱歌。
dic['personal_msg']['hobby_list'][-1] = '唱歌'
print(dic)
在循环dict中，最好不要改变dict的大小，会影响结果或者报错。
dic = {'k1': 'v1', 'k2': 'v2','k3': 'v3','name': 'alex'}
for i in dic:
if 'k' in i:
del dic[i]
print(dic)
l1 = []
for key in dic:
if 'k' in key:
l1.append(key)
# print(l1)
for key in l1:
del dic[key]
print(dic)
dic = dict.fromkeys('abc', 666)
print(dic)
dic = dict.fromkeys([11, 22, 33], 666)
print(dic)
dic = dict.fromkeys([1, 2, 3], [])
dic[1].append(666)
print(dic)
C:\Python\Python36\python3.exe "D:/老男孩12期笔记/day07/day07课堂笔记/day07/02 数据类型的补充.py"
{'a': 666, 'b': 666, 'c': 666}
{11: 666, 22: 666, 33: 666}
{1: [666], 2: [666], 3: [666]}
Process finished with exit code 0
六、元组tuple
元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）
# tu = (11, 22, 33, 44, 55)
#索引，切片，步长
# print(tu[0])
# print(tu[:3:2])
# for i in tu:
# print(i)
# index len count
tu1 = ('wusir', 'alex', [22, 44, 'taibai'],)
# tu1[-1].append('女神')
# print(tu1)
# l1 = [22,33]
# l1.append(tu1)
# # print(l1)
# l1.clear()
# print(l1)
# del tu1
# print(tu1)
# l2 = [1,('wusir', 'alex', [22, 44, 'taibai'],)]
# l2.clear()
# print(l2)
元组里面如果只有一个元素且没有逗号，则该数据的数据类型与里面的元素相同。
tu1 = ('laonanhai')
tu2 = ('laonanhai',)
print(tu1, type(tu1))
print(tu2, type(tu2))
tu1 = (1)
tu2 = (1,)
print(tu1, type(tu1))
print(tu2, type(tu2))
tu1 = ([1, 2, 3])
tu2 = ([1, 2, 3],)
print(tu1, type(tu1))
print(tu2, type(tu2))
七、集合set
集合是无序的，不重复的数据集合，它里面的元素是可哈希的(不可变类型)，但是集合本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点：
去重，把一个列表变成集合，就自动去重了。
关系测试，测试两组数据之前的交集、差集、并集等关系。
1，集合的创建。
set1 = set({1,2,'barry'})
set2 = {1,2,'barry'}
print(set1,set2) # {1, 2, 'barry'} {1, 2, 'barry'}
#空集合表示方法为
set()
2.集合的增
# add
set1 = {'alex','wusir','ritian','egon','barry'}
set1.add('景女神')
print(set1)
#update：迭代着增加
set1.update('A')
print(set1)
set1.update('老师')
print(set1)
set1.update([1,2,3])
print(set1)
3.集合的删
set1 = {'alex','wusir','ritian','egon','barry'}
set1.remove('alex') # 删除一个元素
print(set1)
set1.pop() # 随机删除一个元素
print(set1)
set1.clear() # 清空集合
print(set1)
del set1 # 删除集合
print(set1)
4.集合的查
#for循环
for i in set1:
print(i)
5.集合的交集并集等操作
1.交集（& 或者 intersection）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 & set2) # {4, 5}
print(set1.intersection(set2)) # {4, 5}
2.并集（| 或者 union）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7}
print(set2.union(set1)) # {1, 2, 3, 4, 5, 6, 7}
3.差集（- 或者 difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 - set2) # {1, 2, 3}
print(set1.difference(set2)) # {1, 2, 3}
4.反交集 （^ 或者 symmetric_difference）
set1 = {1,2,3,4,5}
set2 = {4,5,6,7,8}
print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}
print(set1.symmetric_difference(set2)) # {1, 2, 3, 6, 7, 8}
5.子集与超集
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超集。
八、其他（for，enumerate，range）。
1.for循环：用户按照顺序循环可迭代对象的内容。
msg = '老男孩python是全国范围内最好的python培训机构'
for item in msg:
print(item)
li = ['alex','银角','女神','egon','太白']
for i in li:
print(i)
dic = {'name':'太白','age':18,'sex':'man'}
for k,v in dic.items():
print(k,v)
2.enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），
enumerate将其组成一个索引序列，利用它可以同时获得索引和值。
li = ['alex','银角','女神','egon','太白']
for i in enumerate(li):
print(i)
for index,name in enumerate(li,1):
print(index,name)
for index, name in enumerate(li, 100): # 起始位置默认是0，可更改
print(index, name)
3.range：指定范围，生成指定数字。
range 当做自定义的数字范围列表,满足顾头不顾腚,可以加步长，与for循环结合使用。
for i in range(0, 101): #[0,1,2,3,....100]
print(i)
for i in range(11): # [0,1,2,3,....10]
print(i)
for i in range(0, 101, 3):
print(i)
for i in range(10, 0, -1):
print(i)
l1 = [22, 33, 33, 33, 66, 77, 88, 99]
for i in l1:
print(l1.index(i))
for i in range(len(l1)):
print(i)
l1 = ['wusir', 'alex', [99, ' taibai', '98'], 21]
for i in l1:
if type(i) == list:
for j in i:
print(j)
else:print(i)
来源：https://www.cnblogs.com/wj12312/p/9003195.html