1、整数int
int主要用于计算-----“i.bit_length()”:表示i所占用的最少二进制位数。
#int-----i.bit_length():表示i所占用的最少二进制位数。
i= 13
print(i.bit_length())
2、布尔值bool
布尔值就两种：True，False。就是反应条件的正确与否。
真 1 True。
假 0 False。
3、字符串str
string主要用于存放少量的数据，便与后续操作。
整型int和字符串str之间的相互转换：
int ---> str str(int)
str ----> int int(str) str此时只能是数字的组合
整型int和布尔值bool之间的相互转换：
int ----> bool 非0时值为True,为0时值为False
bool ----> int True转换为整数int型时值为1，False转换为整数int型时值为0
# int ---> bool 非0时值为True,为0时值为False
a = bool(2)
b = bool(0)
print(a) #运行结果：True
print(b) #运行结果：False
#bool ---> int True转换为整数int型时值为1，False转换为整数int型时值为0
c = int(True)
d = int(False)
print(c) #运行结果：1
print(d) #运行结果：0
字符串str和布尔值bool之间的相互转换：
str ---> bool 非空 返回值是True，空返回值就是False
bool ---> str str(True) str(False)
#str - --> bool 非空返回值是True，空返回值就是False
i = bool('3')
print(i) #运行结果：True
i = bool(0)
print(i) #运行结果：False
i = bool('')
print(i) #运行结果：False
#bool - --> str str(True) str(False)
i= str(True)
print(i) #运行结果：True
i= str(False)
print(i) #运行结果：False
常见知识点补充：if条件语句和while循环语句中用于条件判断。
if 1:
print('a')
else:
print('b') #运行结果：a
if 0:
print('a')
else:
print('b') #运行结果：b
while True:
print('a')
break #运行结果：a
while 1: # 和while True比较while 1 的执行效率高
print('b')
break #运行结果：b
4、字符串的索引与切片
索引即下标，就是字符串组成的元素从第一个开始，初始索引为0以此类推。
a = "a1b2c3"
print(a[0]) #运行结果：a
print(a[1]) #运行结果：1
print(a[2]) #运行结果：b
切片就是通过索引（起始索引：终止索引：步长）截取字符串的一段，形成新的字符串（原则就是顾头不顾腚）。
a = 'ABCDEFGHIJK'
print(a[0:3])
print(a[2:5])
print(a[0:]) #默认到最后
print(a[:]) #从头到尾
print(a[0:-1]) #-1就是最后一个
print(a[0:5:2]) #加步长
print(a[5:0:-2]) #反向加步长
print(a[-1:-6:-2])#反向取加步长
以上代码的输出结果：
ABC
CDE
ABCDEFGHIJK
ABCDEFGHIJK
ABCDEFGHIJ
ACE
FDB
KIG
字符串常用方法：format与格式化输出类似但是各有不同的应用场景。
#第一种
s = '我叫{},今年{},身高{}'.format('金鑫',21,175)
print(s)
#第二种
s = '我叫{0},今年{1},身高{2},我依然叫{0}'.format('金鑫',21,175)
print(s)
#第三种
s = '我叫{name},今年{age},身高{high}'.format(name = '金鑫',high=175,age=21)
print(s)
字符串的常用方法
s= "aBc d12%h&j(" print(s.capitalize()) #字符串的首字母大写 运行结果：Abc d12%h&j( print(s.swapcase()) #大小写翻转 运行结果：AbC D12%H&J( print(s.title()) # 非字母隔开的地方首字母大写，其它小写 运行结果：Abc D12%H&J( print(s.upper()) #全部大写 运行结果：ABC D12%H&J( print(s.lower()) #大全部小写 运行结果：abc d12%h&j( print(s.center(25)) #将内容居中 运行结果： aBc d12%h&j( print(s.center(25,'*')) #将内容居中两边用*填满 运行结果：*******aBc d12%h&j(****** print(s.expandtabs()) #字符串中的 tab 符号(' ')转为空格，tab 符号(' ')默认的空格数是 8 print(s.find('d')) #通过元素找索引,可以整体找,可以切片,找不到返回-1 运行结果：4 print(s.index('d')) #通过元素找索引,可以整体找,可以切片,找不到会报错 运行结果：4 print(s.startswith('a')) #检查字符串是否是以指定子字符串开头，如果是则返回 True，否则返回 False print(s.endswith('(')) #检查字符串是否是以指定子字符串结尾，如果是则返回 True，否则返回 False print(s.strip()) #去除字符串前后两端的空格,换行符,tab键或指定字符等 运行结果：aBc d12%h&j( print(s.lstrip()) #截掉字符串左边的空格或指定字符 运行结果：aBc d12%h&j( print(s.rstrip()) #截掉字符串右边的空格或指定字符 运行结果：aBc d12%h&j( print(s.split('b',3)) #通过指定分隔符对字符串进行切片--->list 运行结果：['aBc d12%h&j('] print(s.replace('a','小',2)) #用“小”替换字符串里的“a”2次 运行结果：小Bc d12%h&j( print(s.isalnum()) #字符串由字母或数字组成 运行结果：False print(s.isalpha()) #字符串只由字母组成 运行结果：False print(s.isdigit()) #字符串只由数字组成 运行结果：False print(s.count('a')) #统计“a”在字符串中出现的次数。 运行结果：1 print(len(s)) #计算字符串“s”的长度或项目个数 运行结果：12 #strip应用举例： name = input('请输入名字:').strip() if name == 'alex': print('somebody') else: print('请重新输入') #upper和lower应用举例，全部大写和全部小写实际应用：不区分大小写的验证码。 code = 'aeDd' your_code = input('请输入验证码:') if your_code.upper() == code.upper(): print('输入正确') else: print('请重新输入')
5元祖
元组被称为只读列表，即数据可以被查询，但不能被修改，所以，字符串的切片操作同样适用于元组。例：（1，2，3）（"a","b","c"）
元祖里包含的列表元素，此列表的元素可被修改。
元祖也适用count、len、index等。
#元祖的
#当元组只有一个元素组成并且没有','
# 则该元素是什么数据类型,整体就是什么数据类型.
tu1= ([1,2])
print(type(tu1)) #<class 'list'>
tu2 = ('abc')
print(type(tu2)) #<class 'str'>
6列表
列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型。
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
列表的增，共有三种方法：
#第一种：append插在最后 l1 = ['小明','小芳',2,'小花','abc'] l1.append('w') l1.append([1,2,'qq']) print(l1) #运行结果：['小明', '小芳', 2, '小花', 'abc', 'w', [1, 2, 'qq']] #第二种：insert按照索引插入 l1 = ['小明','小芳',2,'小花','abc'] l1.insert(1,"you") print(l1) #运行结果：['小明', 'you', '小芳', 2, '小花', 'abc'] #第三种：extend,批量增加在最后 l1 = ['小明','小芳',2,'小花','abc'] l1.extend([1,'g',9]) print(l1) #运行结果：['小明', '小芳', 2, '小花', 'abc', 1, 'g', 9]
列表的删，共四种方法：
#第一种：pop,默认删除最后一个，也可按照索引删。 l1 = ['小明','小芳',2,'小花','abc'] l1.pop() print(l1) #运行结果：['小明', '小芳', 2, '小花'] l1 = ['小明','小芳',2,'小花','abc'] ret = l1.pop(2) #有返回值 print(ret) #运行结果：2 print(l1) #运行结果：['小明', '小芳', '小花', 'abc'] #第二种:remove,按照指定元素删除 l1 = ['小明','小芳',2,'小花','abc'] l1.remove("小明") print(l1) #运行结果：['小芳', 2, '小花', 'abc'] #第三种：clear，清空列表 l1 = ['小明','小芳',2,'小花','abc'] l1.clear() print(l1) #运行结果：[] #第四种： # del:删除列表 l1 = ['小明','小芳',2,'小花','abc'] del l1 #按照索引删除：也可以切片删除 l1 = ['小明','小芳',2,'小花','abc'] del l1[2] print(l1) #运行结果：['小明', '小芳', '小花', 'abc'] l1 = ['小明','小芳',2,'小花','abc'] del l1[0:1] print(l1) #运行结果：['小芳', 2, '小花', 'abc']
列表得改：
l1 = ['小明','小芳',2,'小花','abc'] #按照索引改， l1[0] = '小马' print(l1) #运行结果：['小马', '小芳', 2, '小花', 'abc'] #按照切片改 l1[0:2] = ['小猫','小狗'] print(l1) #运行结果：['小猫', '小狗', 2, '小花', 'abc']
列表的查：
#列表的查
l1 = ['小明','小芳',2,'小花','abc']
#按照索引查
l1[1] #运行结果：小芳
print(l1[1])
#按照切片查
l1[0:2]
print(l1[0:2]) #运行结果：['小明', '小芳']
#for循环来查
for i in l1:
print(i)
其他操作：
count（数）（方法统计某个元素在列表中出现的次数）。
1 a = ["q","w","q","r","t","y"]
2 print(a.count("q"))
index（方法用于从列表中找出某个值第一个匹配项的索引位置）
1 a = ["q","w","r","t","y"]
2 print(a.index("r"))
len（计算列表的长度）
#len计算列表的长度
l1 = ['小明','小芳',2,'小花','abc']
len(l1)
print(len(l1)) #运行结果：5
sort （方法用于在原位置对列表进行排序）
reverse （方法将列表中的元素反向存放）
# sort从小到大排序
l1 = [1,4,6,3,8,7]
l1.sort()
print(l1) #运行结果：[1, 3, 4, 6, 7, 8]
#将列表反向排序
l1 = [1,4,6,3,8,7]
l1.reverse()
print(l1) #运行结果：[7, 8, 3, 6, 4, 1]
#将列表反向按照从大到小排序
l1 = [1,4,6,3,8,7]
l1.sort(reverse = True)
print(l1) #运行结果：[8, 7, 6, 4, 3, 1]
range的用法：指定范围，生成指定数字。
#range当做:范围列表[],列表中的元素是数字,且可控的有效数字范围
#一般与for 配合使用
for i in range(1,5):
print(i) #运行结果：1234
for i in range(4):
print(i) #运行结果：0123
for i in range(1,10,2):
print(i) #运行结果：13579
for i in range(5,0,-1):
print(i) #运行结果：54321
for i in range(5,-2,-1):
print(i) #运行结果：543210-1
Join的用法：
#join的用法：
s = 'adhey'
s1 = '-'.join(s)
print(s1) #运行结果：a-d-h-e-y
7、字典
Python中的数据类型分为可变类型与不可变类型：
可变类型：int、str、bool、tuple.
不可变类型：list、dic、set
字典是python中非常重要的数据类型,在python中唯一一个映射的数据类型。
字典的特点：
1）字典的形式：{key,value}
2）key是唯一的且是不可变数据类型，value则可以是任意数据类型。
3）字典可以存放大量的数据，且关联性较强。
4）在Python3.5版本之前字典是无序的，但是在Python3.6版本（包括3.6）是有序的。
字典的操作包括增删改查：
字典的增：
第一种：dic[key] = value #特点：有key就覆盖，没key就增加。 dic['name'] = '小白' print(dic) #运行结果：{'name': '小白', 'name_list': ['小芳','小猫']} #第二种：dic.setdafault() #特点：有key不变，没key就增加 dic ={'name':"小明",'name_list':['小芳','小猫']} dic.setdefault('name1','ok') print(dic) #{'name': '小明', 'name_list': ['小芳', '小猫'], 'name1': 'ok'}
字典的删：
#第一种：dic.pop(key),按照key删，有返回值,返回value。 #如果要删除的key值不存在，则可以返回制定的值。 dic ={'name':"小明",'name_list':['小芳','小猫']} ret = dic.pop('name') print(dic,ret) #{'name_list': ['小芳', '小猫']} 小明 #第二种：dic.clear dic ={'name':"小明",'name_list':['小芳','小猫']} dic.clear() print(dic) #{} #第三种：del dic 删除整个字典 del dic[name]删除键值对， dic ={'name':"小明",'name_list':['小芳','小猫']} # del dic del dic['name'] print(dic) #{'name_list': ['小芳', '小猫']} #第四种：del.popitem（） # 随机删除有返回值以元祖形式返回被删除的值 dic ={'name':"小明",'name_list':['小芳','小猫']} ret = dic.popitem() print(ret) #('name_list', ['小芳', '小猫']) print(dic) #{'name': '小明'}
字典的改：
改字典的查：
#第一种：dic['name'] dic ={'name':"小明",'name_list':['小芳','小猫']} print(dic['name']) #小明 #第二种：dic.get('name'),返回自己定的值，没写返回None dic ={'name':"小明",'name_list':['小芳','小猫']} ret = dic.get('name1') print(ret) #None
字典的其它操作：
#取出所有的key
dic ={'name':"小明",'name_list':['小芳','小猫']}
a = dic.keys()
print(a,type(a))#dict_keys(['name', 'name_list']) <class 'dict_keys'>
#取出所有的value
dic ={'name':"小明",'name_list':['小芳','小猫']}
a = dic.values()
print(a,type(a))#dict_values(['小明', ['小芳', '小猫']]) <class 'dict_values'>
#取出所有的键值对（可迭代的）
dic ={'name':"小明",'name_list':['小芳','小猫']}
a = dic.items()
print(a,type(a))#dict_items([('name', '小明'), ('name_list', ['小芳', '小猫'])
字典的for循环
for循环
dic ={'name':"小明",'name_list':['小芳','小猫']}
for k in dic: #name
print(k) #name_list
for k in dic.keys(): #name
print(k) #name_list
for v in dic.values(): #小明
print(v) #['小芳', '小猫']
for k,v in dic.items(): #name 小明
print(k,v) #name_list ['小芳', '小猫']
在循环一个字典时,如果删除某些键值对,可能会报错：
dic= {'k1':'alex','k2':'太白','k3':'日天','name':'wusir'}
#直接删除会报错
for i in dic:
if 'k' in i:
del dic[i]# for i in dic:
# RuntimeError: dictionary changed size during iteration
正确的循环时删除字典键值的方法：
#正确的删除方法
l1 = []
for i in dic:
if 'k' in i:
l1.append(i)
print(l1) #['k1', 'k2', 'k3']
for k in l1:
del dic[k]
print(dic) #{'name': 'wusir'}
字典的特殊数据类型与list之间的转换
#字典的特殊数据类型与list之间的转换
dic = {'k1':'alex','k2':'太白','k3':'日天','name':'wusir'}
print(type(dic.keys())) #数据类型<class 'dict_keys'>
print(type(dic.values())) #数据类型<class 'dict_values'>
print(type(dic.items())) #数据类型<class 'dict_items'>
print(list(dic.keys())) #['k1', 'k2', 'k3', 'name']
print(list(dic.values())) #['alex', '太白', '日天', 'wusir']
print(list(dic.items())) #[('k1', 'alex'), ('k2', '太白'), ('k3', '日天'), ('name', 'wusir')]
8、集合
1）集合是无序的，不重复的数据类型；
2）集合里面的元素必须是可哈希的，例如：int、str、bool等不可变数据类型；
3) 集合本身是不可哈希的；
4）集合里面的元素不能更改，因为集合里的元素是可哈希的；
5） 集合可以求交集、并集、差集、反交集、超集等。
创建一个集合：
#集合的创建
set1 = set({'a','b','c'})
set1 = {1,2,'a','b'}
集合的不可重复性：
#集合的自动去重
l1= ['a','b','b','c','c','d']
set1 = set(l1)
l1 = list(set1)
print(l1) #把相同的元素都去除['d', 'c', 'b', 'a']
集合的增删查：
集合的增有两种：
1）添加一个单独的元素
#单独一个元素的增
set1 = {1,2,'a','b'}
set1.add('x')
print(set1) #元素的增{1, 2, 'b', 'x', 'a'}
2）迭代的增
#集合迭代的增 set1 = {1,2,'a','b'} set2 = {'a','s',5} set2.update(set1) #将set1的内容迭代的增加到set里面 print(set2) #{1, 's', 'a', 2, 5, 'b'} print(set1) #{1, 2, 'a', 'b'}
set2.update（[1,2]）
print(set2) #{1, 2, 'a', 5, 'b', 's'}
集合的删有四种：
#集合的删
#第一种：remove
set1 = {1,2,'a','b'}
set1.remove('a')
print(set1) #{1, 2, 'b'}
#第二种：pop
set1 = {1,2,'a','b'}
set1.pop()
print(set1) #随机删除一个元素
#第三种：清空集合clear
set1 = {1,2,'a','b'}
set1.clear()
print(set1) #结果：set()
#第四种：del，直接删除
set1 = {1,2,'a','b'}
del set1
print(set1) #NameEror:name 'set1' is not defined
集合的查：
#集合的查
#循环打印显示集合的内容
set1 = {1,2,'a','b'}
for i in set1:
print(i)
集合的交集、并集、差集、反交集、超集：
交集：
#交集 'set1 & set2'或者set1.intersection(set2) set1 = {1,2,'a','b'} set2 = {1,2,'c'} set3 = set1 & set2 print(set3) #{1, 2} set4 = set1.intersection(set2) print(set4) #{1, 2}
并集：
#并集 'set1 | set2'或者 set1 = {1,2,'a','b'} set2 = {1,2,'c'} set3 = set1 | set2 print(set3,id(set3)) #{1, 2, 'c', 'b', 'a'} 4818864 set4 = set1.union(set2) print(set4,id(set4)) #{1, 2, 'c', 'b', 'a'} 7220680
反交集：
#反交集:'set1 ^ set2'或者‘set1.symmetric_difference(set2)’ set1 = {1,2,'a','b'} set2 = {1,2,'c'} set3 = set1 ^ set2 print(set3) #{'a', 'c', 'b'} set4 = set1.symmetric_difference(set2) print(set4) #{'a', 'c', 'b'}
差集：
#差集：'set1 -set2'或者’set1.difference(set2)' set1 = {1,2,'a','b'} set2 = {1,2,'c'} set3 = set1 -set2 print(set3) #{'b', 'a'} set4 = set1.difference(set2) print(set4) #{'b', 'a'} set5 = set2.difference(set1) print(set5) #{'c'}
超集：
#超集：'set1 < set2'或者'set2.issubset(set1)' set1 = {1,2,'a','b'} set2 = {1,2} set3 = set1 < set2 print(set3) #False set4 = set2.issubset(set1) print(set4) #True set5 = set1.issuperset(set2) print(set5) #True set6 = set2.issuperset(set1) print (set6) #False
frozenset：
frozenset不可变集合，让集合变成不可变类型
#frozenset set1 = {1,2,'a','b'} s1 = frozenset(set1) print(s1,type(s1)) #frozenset({1, 2, 'a', 'b'}) <class 'frozenset'>