Python笔记2（数据类型）⼀、数字int
数字主要是⽤于计算、运算。使⽤⽅法并不是很多，就记住⼀种就可以：
1'''
2bit_length()将⼗进制转化为⼆进制站的位数
3⼆进制⼗进制
40000 0001 1
50000 0010 2
60000 0011 3
70000 0100 4
8'''
9 i=3
10 j=4
11print(i.bit_length())#>>>2
12print(j.bit_length())#>>>3
⼆、布尔值bool
布尔值就两种：True，False。就是反应条件的正确与否。
1'''
2数字与字符串转化
3 int ---> str : str(int)
4 str ---> int : int(str) str必须全部是数字组成
5布尔型与数字、字符串转化
6 int ---> bool：0 ---> False ⾮0 ---> True
7 bool---> int ：int(True)---> 1 int(False)---> 0
8 str ---> bool：空字符串 ---> False ⾮空字符串---> True
9'''
10print(int(True))#>>>1
11print(int(False))#>>>0
12print(bool(''))#>>>False
13print(bool('a'))#>>>False
三、字符串
1、字符串的索引
索引即下标，就是字符串组成的元素从第⼀个开始，初始索引为0以此类推。
1 s='Hello World!'
2 s1=s[0]#第⼀个元素
3 s2=s[-1]#最后⼀个元素
4 s3=s[-2]#倒数第⼆个元素
5print(s1)#>>>H
6print(s2)#>>>!
7print(s3)#>>>d
2、字符串的切⽚
切⽚就是通过索引（索引：索引：步长）截取字符串的⼀段，形成新的字符串（原则就是顾⾸不顾尾）。
s1=s[起始索引：结束索引：步长]
1 s='Hello World!'
2 s1=s[0:3]#从字符串的第1个字符到第3个字符进⾏切⽚
3 s2=s[:3]#0可以省略
4 s3=s[3:9]#从字符串的第4个字符到第9个字符进⾏切⽚
5 s4=s[:5:2]#从字符串的第1个字符到第5个字符进⾏切⽚，加步长2
6 s5=s[:]#把字符串全部取出来
7 s6=s[-1:-4:-1]#反向取字符串，加反向步长
8print(s1)#>>>Hel
9print(s2)#>>>Hel
10print(s3)#>>>lo Wor
11print(s4)#>>>Hlo
12print(s5)#>>>Hello World!
13print(s6)#>>>!dl
3、字符串常⽤的⽅法
1）* captalize() ⾸字母⼤写
1 s='Hello World!'
2 s1=s.capitalize()
3print(s1)#>>>Hello world!
2）***upper() 字母全部⼤写 lower() 字母全部⼩写
1 s='Hello World!'
2 s2=s.upper()
3 s3=s.lower()
4print(s2)#>>>HELLO WORLD!
5print(s3)#>>>hello world!
1#例验证码不区分⼤⼩写
2 code = 'QcaR'.upper()
3 your_code =input('请输⼊验证码：').upper()
4if your_code == code :
5print('验证成功')
3）swapcase() ⼤⼩写翻转
1 s='Hello World!'
2 s1=s.swapcase()
3print(s1)#>>>hELLO wORLD!
4）title() ⾮字母的元素隔开的每个单词⾸字母⼤写
1 msg='hello world_hello*world'
2print(msg.title())#>>>Hello World_Hello*World
5）center() 内容居中，总长度⾃⼰设定，默认填充None
4print(s1)#>>>****Hello World!****
5print(s2)#>>> Hello World!
6）*** strartwith() 判断以什么为开头 *** endswith() 判断以什么为结尾
1 s='Hello World!'
2 s1=s.startswith('H')
3print(s1)#>>>True
4 s2=s.startswith('He')
5print(s2)#>>>True
6 s3=s.startswith('e',1,5)#切⽚截取的字符串是否以‘e’为开头
7print(s3)#>>>True
8 dswith('!')
9print(s4)#>>>True
7）strip() 去除⾸位的空格，制表符\t，换⾏符\n。不仅仅是去除空格
注：lstrip() 只除字符串左边的；rstrip() 只除字符串右边的；
1 s=' Hello World! '
2 ss='\tHello World!\n'
3 s1=s.strip()
4print(s1)#>>>Hello World!
5 s2=ss.strip()
6print(s2)#>>>Hello World!
7 sss='tHello World!te'
8 s3=sss.strip('t')#去掉字符串⾸尾的‘t’
9print(s3)#>>>Hello World!te
10 s4=sss.strip('tey')#跌带去除⾸尾的‘t’、‘e’、‘y’，⽆序
11print(s4)#>>>Hello World!
1# 例去除⽤户输⼊的空格
2 name = input('>>>').strip()
3if name == 'oldboy':
4print('验证成功')
8）#split() 字符串转化列表
1 s='Hello World!'
2 s1=s.split()
3print(s1)#>>>['Hello', 'World!']
4 ss='He,llo Wo,rld!'
5 s2=ss.split(',')
6print(s2)#>>>['He', 'llo Wo', 'rld!']
7 sss='oHello World!'
8 s3=sss.split('o')
9print(s3)#>>>['', 'Hell', ' W', 'rld!']
10 s4=sss.split('o',1)
11print(s4)#>>>['', 'Hello World!']
9）join() 将列表转化字符串
注：如果列表⾥是⾮字符串元素，会报错
s='Hello World!'
s1='+'.join(s)
print(s1)#>>>H+e+l+l+o+ +W+o+r+l+d+!
s2='_'.join(s)
print(s2)#>>>H_e_l_l_o_ _W_o_r_l_d_!
ss=['Hello','World','!']
s3='_'.join(ss)
print(s3)#>>>Hello_World_!
10）replace() 把字符串的旧字符串替换成新的字符串，如果指定第三个参数max，则替换不超过max次。
语法：place(old,new[,max])
1 s='Hello World!'
2 place('W','w')
3print(s1)#>>>Hello world!
11）find() 通过元素索引 index() 通过元素索引不到元素会报错
1 s='Hello World!'
2 s1=s.find("e",1,6)
3print(s1)#>>>1
4 s2=s.find("m",1,6)
5print(s2)#>>>-1
6 s2=s.index("o",1,6)
7print(s2)#>>>4
12）formac() 格式化输出
1 s1='我叫{}，今年{}岁，爱好{}'.format('Lucy','18','⽻⽑球')
2print(s1)#>>>我叫Lucy，今年18岁，爱好⽻⽑球
3 s2='我叫{0}，今年{1}岁，爱好{2}'.format('Lucy','18','⽻⽑球')#可以按照索引进⾏替换
4print(s2)#>>>我叫Lucy，今年18岁，爱好⽻⽑球
13）is系列
1 s='a123'
2print(s.isdigit())#字符串由数字组成
3print(s.isalpha())#字符串由字母组成
4print(s.isalnum())#字符串由字母或数字组成
14）公共⽅法：len() 返回对象的长度或项⽬个数； count() 数字字符串的元素出现的个数
1 s='hello world'
2 s1=len(s)
3print(s1)#>>>11
4 unt("l",0,10)
5print(s2)#>>>3
四、列表
列表是python中的基础数据类型之⼀，其他语⾔中也有类似于列表的数据类型，⽐如js中叫数组。列表相⽐于字符串，不仅可以储存不同的数据类型，⽽且可以储存⼤量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。⽽且列表是有序的，有索引值，可切⽚，⽅便取值。
1、增
4print(l1)#>>>[111, 'aaa', 222, 'bbb', '123abc']
5#insert() 插⼊
6 l2=[111,'aaa',222,'bbb']
7 l2.insert(1,'ccc')
8print(l2)#>>>[111, 'ccc', 'aaa', 222, 'bbb']
9#extend 迭代着增加
10 l3=[111,'aaa',222,'bbb']
d('ddd')
12print(l3)#>>>[111, 'aaa', 222, 'bbb', 'd', 'd', 'd']
13 l4=[111,'aaa',222,'bbb']
d(['333','444'])
15print(l4)#>>>[111, 'aaa', 222, 'bbb', '333', '444']
列表的增
2、删
1#pop 按照索引删除，有返回值，增删改查中唯⼀⼀个有返回值的 2 l1=[111,'aaa',222,'bbb']
3print(l1.pop(0))#>>>111
4print(l1)#>>>['aaa', 222, 'bbb']
5#remove
6 l1=[111,'aaa',222,'bbb']
ve('aaa')
8print(l1)#>>>[111, 222, 'bbb']
9#clear 清空列表，删除内容，但是在内存中还占⽤空间
10 l1=[111,'aaa',222,'bbb']
11 l1.clear()
12print(l1)#>>>[]
13#del 内存级别删除列表
14 l1=[111,'aaa',222,'bbb']
15del l1
16print(l1)#报错，内存中删除列表
17#del 按照元素删除
18 l1=[111,'aaa',222,'bbb']
19del l1[1]
20print(l1)#>>>[111, 222, 'bbb']
21#del 切⽚删除
22 l1=[111,'aaa',222,'bbb']
23del l1[:3]
24print(l1)#>>>['bbb']
列表的删
3、改
1#按照索引去改
2 l1=[111,'aaa',222,'bbb']
3 l1[2]='ccc'
4print(l1)#>>>[111, 'aaa', 'ccc', 'bbb']
5#按切⽚去改 1.按切⽚的元素删除；2.按照添加的组成最⼩元素添加
6 l1=[111,'aaa',222,'bbb']
7 l1[:2]='abc'
8print(l1)#>>>['a', 'b', 'c', 222, 'bbb']
列表的改
4、查
1 li=[111,'aaa',222,'bbb']
2#按照索引去查
3print(li[1])#>>>aaa
4print(li[-1])#>>>bbb
5#按照切⽚查询
6print(li[:2])#>>>[111, 'aaa']
7print(li[:3:2])#>>>[111, 222]
8#循环for
9for i in li:
10print(i)
列表的查
5、其他⽅法
1#count 计数
2 l1=[111,'aaa',222,'bbb','aaa']
unt('aaa'))#>>>2
4#len 返回对象的长度
5print(len(l1))#>>>5
6#通过元素索引列表中只有index
7print(l1.index('aaa'))#>>>1
8#排序
9# sort() 从⼩到⼤或从⼤到⼩排序
10 l1=[3,6,4,7,6,9,1,2,5,0]
11 l1.sort()#从⼩到⼤排序
12print(l1)#>>>[0, 1, 2, 3, 4, 5, 6, 6, 7, 9]
13 l1.sort(reverse=True)#从⼤到⼩排序
14print(l1)#>>>[9, 7, 6, 6, 5, 4, 3, 2, 1, 0]
15#reverse 反向排序
16 l1=[3,6,4,7,6,9,1,2,5,0]
verse()
18print(l1)#>>>[0, 5, 2, 1, 9, 6, 7, 4, 6, 3]
count() len() sort() reverse()
6、列表的嵌套
1 l1=[111,'aaa',222,'bbb',['ccc','ddd',10]]
2# 1.将aaa全部变成⼤写
3# ⽅法⼀
4 l1[1]='AAA'
5print(l1)#>>>[111, 'AAA', 222, 'bbb', ['ccc', 'ddd',10]]
6# ⽅法⼆
7 l1[1]=l1[1].upper()
8print(l1)#>>>[111, 'AAA', 222, 'bbb', ['ccc', 'ddd',10]]
9# 2.给['ccc','ddd']追加'eee'
10 l1[-1].append('eee')
11print(l1)#>>>[111, 'aaa', 222, 'bbb', ['ccc', 'ddd',10, 'eee']]
12# 3.将'ccc'⾸字母⼤写
17 l1[-1][-1]=str(l1[-1][-1]+90)
18print(l1)#>>>[111, 'aaa', 222, 'bbb', ['ccc', 'ddd', '100']]
19# ⽅法⼆
20 l1[-1][-1]=str(l1[-1][-1])+'0'
21print(l1)#>>>[111, 'aaa', 222, 'bbb', ['ccc', 'ddd', '100']]
列表的嵌套
五、字典
字典的key是唯⼀的。key必须是不可变的数据类型，value是任意数据类型。
数据类型分类：
不可变数据类型（可哈希）：str，bool,tuple,int。
可变数据类型（不可哈希）：dict，list，set。
容器类数据类型：list，tuple，dict，set。
字典：存储数据多，关系型数据，查询速度快(⼆分查)
⼆分查：也称折半查（Binary Search），它是⼀种⾼效率的查⽅法。但是，折半查要求线性表必须采⽤顺序存储结构，⽽且表中的元素按关键字有序排列。备注：python3.5以前 (包含3.5)，字典⽆序
python3.6以后 (包含3.6)，进⾏了优化，不清楚到底是有序还是⽆序
1 dic={'name':'lucy','age':'18',[1,2,3]}
2print(dic)#输出时会报错，因为列表是不可哈希类型
1、增
1#'='有则覆盖，⽆则添加
2 dic={'name':'lucy','age':'18','hobby':'⽻⽑球'}
3 dic['high']=170#有则不变，⽆则添加
4print(dic)#>>>{'name': 'lucy', 'age': '18', 'hobby': '⽻⽑球', 'high': 170}
5#setdefault() 有则不变，⽆则添加
6 dic={'name':'lucy','age':'18','hobby':'⽻⽑球'}
7 dic.setdefault('high')
8print(dic)#>>>{'name': 'lucy', 'age': '18', 'hobby': '⽻⽑球', 'high': None}
9 dic={'name':'lucy','age':'18','hobby':'⽻⽑球'}
10 dic.setdefault('high',170)
11print(dic)#>>>{'name': 'lucy', 'age': '18', 'hobby': '⽻⽑球', 'high': 170}
12 dic.setdefault('name','lily')#>>>{'name': 'lucy', 'age': '18', 'hobby': '⽻⽑球', 'high': 170}
13print(dic)
列表的增
2、删
1#pop() pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
2 dic={'name':'lucy','age':'18','hobby':'⽻⽑球'}
3print(dic.pop('name'))#>>>lucy
4print(dic)#>>>{'age': '18', 'hobby': '⽻⽑球'}
5#pop() 删除不存在的键不会报错，返回对应的值
6 dic={'name':'lucy','age':'18','hobby':'⽻⽑球'}
7print(dic.pop('name1',None))#>>>None None位置可以输⼊任意值
8print(dic)#>>>{'name': 'lucy', 'age': '18', 'hobby': '⽻⽑球'}
9#clear() 清空字典
10 dic.clear()
11print(dic)#>>>{}
12#del() 内存级别删除
13del dic
14print(dic)#打印时会报错，因为在内存级别已经删除
15 dic={'name':'lucy','age':'18','hobby':'⽻⽑球'}
16del dic['age']
17print(dic)#>>>{'name': 'lucy', 'hobby': '⽻⽑球'}
18#popitem()随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回，在python3.6以后，默认删除最后⼀个键值对
19 dic={'name':'lucy','age':'18','hobby':'⽻⽑球'}
20print( dic.popitem())#>>>('hobby', '⽻⽑球')
21print(dic)#>>>{'name': 'lucy', 'age': '18'}
列表的删
3、改
1#'='
2 dic={'name':'lucy','age':'18','hobby':'⽻⽑球'}
3 dic['name']='Lily'
4print(dic)#>>>{'name': 'Lily', 'age': '18', 'hobby': '⽻⽑球'}
5#update() 将dic1覆盖添加dic2中，dic1不变
6 dic1={'name':'lucy','age':'18','hobby':'⽻⽑球'}
7 dic2={'name':'Lily','high':170}
8 dic2.update(dic1)
9print(dic2)#>>>{'name': 'lucy', 'high': 170, 'age': '18', 'hobby': '⽻⽑球'}
列表的改
4、查
1#直接按照键查
2 dic={'name':'lucy','age':'18','hobby':'⽻⽑球'}
3print(dic['name'])#>>>lucy
4#get() 查不到不会报错，返回None
('name1'))#>>>None
('name1','没有此key'))#>>>没有此key
7
8#keys() values() items()
9 dic={'name':'lucy','age':'18','hobby':'⽻⽑球'}
10#keys()
11print(dic.keys())#>>>dict_keys(['name', 'age', 'hobby'])
12print(list(dic.keys()))#>>>['name', 'age', 'hobby']
13#values()
14print(dic.values())#>>>dict_values(['lucy', '18', '⽻⽑球'])
15print(list(dic.values()))#>>>['lucy', '18', '⽻⽑球']
16#items()
17print(dic.items())#>>>dict_items([('name', 'lucy'), ('age', '18'), ('hobby', '⽻⽑球')])
18print(list(dic.items()))#>>>[('name', 'lucy'), ('age', '18'), ('hobby', '⽻⽑球')]
19#for循环取值
20 dic={'name':'lucy','age':'18','hobby':'⽻⽑球'}
21for i in dic.keys():
25for i in dic.items():
26print(i)
27for k,v in dic.items():
28print(k,v)
29#分别赋值
30 a,b=1,2
31print('a=',a,'b=',b)#>>>a= 1 b= 2
32 a,b=b,a
33print('a=',a,'b=',b)#>>>a= 2 b= 1
34 a,b,c=['Lily','Lucy','Lucas']
35print('a=',a,'b=',b,'c=',c)#>>>a= Lily b= Lucy c= Lucas
列表的查
5、公共⽅法 len()
1 dic={'name':'lucy','age':'18','hobby':'⽻⽑球'}
2print(len(dic))#>>>3
6、fromkeys() 创建字典⼀种，以fromkeys()创建的键值对，如果值是列表的话，多个共⽤的都是⼀个列表
1 dic={}
2 dic1=dic.fromkeys('abc','张三')
3print(dic1)#>>>{'a': '张三', 'b': '张三', 'c': '张三'}
4 dic2=dic.fromkeys([1,2,3],'李四')
5print(dic2)#>>>{1: '李四', 2: '李四', 3: '李四'}
6 dic3=dic.fromkeys('abc',[])
7 dic3['a'].append('张三')
8print(dic3)#>>>{'a': ['张三'], 'b': ['张三'], 'c': ['张三']}
7、字典的嵌套
1 dic = {
2'name_list':['b哥', '张帝', '⼈帅', 'kitty'],
3'⽼男孩':{
4'name':'⽼男孩',
5'age': 46,
6'sex': 'ladyboy',
7 }
8 }
9#1、['b哥', '张帝', '⼈帅', 'kitty']追加⼀个骑兵
10 dic['name_list'].append('骑兵')
11print(dic)
12#2、将kitty全部变成⼤写
13 dic['name_list'][-1]=dic['name_list'][-1].upper()
14print(dic)
15#3、将'name':'⽼男孩',⽼男孩改成oldboy
16 dic['⽼男孩']['name']='oldboy'
17print(dic)
18#4、将ladyboy⾸字母⼤写
19 dic['⽼男孩']['sex']=dic['⽼男孩']['sex'].capitalize()
20print(dic)
六、元组
python的元组与列表类型，不同之处在于元组的元素不能修改（增删改）。
元组使⽤⼩括号()，列表使⽤⽅括号[]。
js的基本数据类型元组创建很简单，只需要在括号⾥添加元素，并使⽤逗号隔开即可。
1 tu=(11,2,True,[2,3,4],'alex')
2#循环查询
3# for i in tu:
4# print(i)
5#切⽚查询
6print(tu[1])#>>>2
7print(tu[:3:2])#>>>(11, True)
8#index() 通过元素索引 count() 元素出现的个数 len() 元素的个数
9print(tu.index(True))#>>>2
unt(2))#>>>1
11print(len(tu))#>>>5
12#元素⾥⾯的元素可以修改
13 tu[-2].append('a')
14print(tu)#(11, 2, True, [2, 3, 4, 'a'], 'alex')
元组的查
七、集合
集合：⽆序不重复的数据类型。它⾥⾯的元素必须是可哈希的，但是集合本⾝是不可哈希的。
1、关系测试，交集，并集，⼦集，差集
2、去重（列表的去重）
1 set1={1,'alex',False,(1,2,3)}
2 l1=[1,1,2,2,3,3,4,5,6,6]
3 l2=(list(set(l1)))
4print(l2)#>>>[1, 2, 3, 4, 5, 6]
1、增删改查
1#集合的增⽆序2set1={'Lily','Lucy'}3set1.add('Lucas')4print(set1)#>>>{'Lucas','Lily','Lucy'}5#跌带着增加update()6set1={'Lily','Lucy'}7set1.update('Lucas')8print(set1)#>>>{'a','Lily','u','c','L','s','Lucy'}9#集合的删10#remove()按照元素删除11set1={集合的增删改查
2、集合其他操作
1）交集
1 set1={1,2,3,4,5}
2 set2={4,5,6,7,8}
3print(set1 & set2 )#>>>{4, 5}
4print(set1.intersection(set2))#>>>{4, 5}
2）并集
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论