基本数据类型
所有的方法(函数)都带括号，且括号内没带等号的参数需传给它一个值，带等号的参数相当于有默认值
1.数字 int
在64位系统上，整数的位数为64位，取值范围为-2**63～2**63-1，即-9223372036854775808～9223372036854775807
a=""
b=int(a)
print(type(a),a)
print(type(b),b) 》》<class 'str'> 123
》》<class 'int'> 123 ################################
num="a"
v=int(num,base=16)#base=16代表转换为16进制，16进制中a=10，b=11
print(v) 》》10
#####################
age=3
r=age.bit_length()#该方法表示当前数字的二进制，至少用n位表示
print(r) 》》2
2.字符串 str
“hello world”
a=""
b=int(a)
print(type(a),a)
print(type(b),b) 》》<class 'str'> 123
》》<class 'int'> 123 #####################
num="a"
v=int(num,base=16)#base=16代表转换为16进制，16进制中a=10，b=11
print(v) 》》10 #####################
age=3
r=age.bit_length()#该方法表示当前数字的二进制，至少用n位表示
print(r) 》》2 #####################
test="alex"
v=test.capitalize()#该方法表示将首字母大写
print(v) 》》Alex ####################
#这两个方法都是将字符串所有变小写，casefold()更牛逼
test1="ALEX"
v1=test.casefold()
v2=test.lower()
print(v1,v2) >>alex alex ###################
#这个方法相当于设置宽度，并将内容居中，20代表总长，‘%’代表填充物
v3=test.center(20,'%')
print(v3) >>%%%%%%%%alex%%%%%%%% ##################
#这个方法是计算当前字符串中寻找子序列个数
test4="dasdfgrtert"
v4=test4.count('d',2,60)#‘d’为寻找目标，2和60表示从第2位开始，第60位结束
print(v4) >>1 #############################
#以什么结尾
#以什么开头
test5="alex"
v5=test5.endswith('s')
v6=test5.startswith('a')
print(v5) 》》False
》》True ################################
#这个方法表示从开始往后找，找到第一个之后，获取其位置
test6="alexalex"
v6=test6.find('ex',5,7)#返回-1则没找到，5，7表示[5,7)的前开后闭的区间中找
print(v6) 》》6 ##############################
#格式化，将字符串中的占位符替换为指定的值
test7='i am {name}，{age}'
print(test7)
v7=test7.format(name='alex',age=13)
print(v7) 》》i am {name}，{age}
》》i am alex，13
test8='i am {0}，{1}'
print(test8)
v8=test8.format('alex',13)
print(v8)
》》i am {0}，{1}
》》i am alex，13
#格式化，传入的值{"name":'alsss',"age":19}，相当于字典，"name"和"age"为键
v9=test7.format_map({"name":'alsss',"age":19})
print(v9)
》》i am alsss，19
########################
#判断字符串中是否只包含字母和数字
test10="asfer454r"
v10=test10.isalnum()
print(v10) 》》True
#expandtabs()相当于断句，
test="12345678\t9"
v=test.expandtabs(6)#6表示6个字符串为一句，\t表示空格,若出现\t则用空格补齐6个字符串
print(v,len(v))#len()表示字符串长度 》》12345678 9 13 test1="name\tage\tgender\nManuel\t25\tmale\nApril\t25\tfemale\n"
v1=test1.expandtabs(10)
print(v1) 》》
name age gender
Manuel 25 male
April 25 female ####################################
#isalpha()判断当前字符串是否是字母
#isdecimal()和isdigit()（更牛）和isnumeric()(最牛)判断当前字符串是否是数字
test2="rggds"
v2=test2.isalpha()
v3=test2.isdecimal()
v4=test2.isdigit()
v5=test2.isnumeric()
print(v2,v3,v4) 》》True False False False ############################### #是否存在不可显示的字符
#\t 制表符
#\n 换行
test6="wertwet\twe"
v6=test6.isprintable()
print(v6) 》》False
isspace()#判断字符串内是否全是空格
istitle()#判断字符串是否是标题（所有单词首字母大写）
title()将输入转换为标题的格式
#jion()将字符串中的每一个元素按照指定分隔符进行拼接
test7="你是风儿我是沙"
t='_'
v7=t.join(test7)
print(v7) 》》你_是_风_儿_我_是_沙
ljust()、rjust()与center()类似，区别是将字符串放左边（右边），填充字符串放右边（左边）
islower()、isupper()判断字符串是否为小写、大写
lower()、upper()将字符串变成小写、大写
strip()、lstrip()、rstrip()去掉字符串所有、左边、右边的空格或换行符，括号内为去掉的参数（且参数子序列也可），默认为空格
#maketrans()建立对应关系，translate()利用对应关系替换
v8="sssdawrwq"
m=str.maketrans("sda","")
v9=v8.translate(m)
print(v9) 》》11123wrwq
#以下方法都是分割
test10="twqedafsdwsewq"
m1=test10.partition('e')#只能将字符串分割成3份，遇到的第一个‘e’就分割，且保留‘e’
m2=test10.rpartition('e')#同上，但是是从右往左
m3=test10.split('e')#不保留‘e’，默认全部分割，再传个参数可以指定分割次数
m4=test10.rsplit('e',1)#同上，从右往左
print(m1)
print(m2)
print(m3)
print(m4) 》》('twq', 'e', 'dafsdwsewq')
》》('twqedafsdws', 'e', 'wq')
》》['twq', 'dafsdws', 'wq']
》》['twqedafsdws', 'wq']
#正则表达式中可以设置是否想要分割的元素，相当于上面两种方法的合集 #这个方法是根据换行符分割，True，False：指定是否保留换行符
test11='qwerer\nqweqw\nwafaef'
m5=test11.splitlines(True)
print(m5) 》》['qwerer\n', 'qweqw\n', 'wafaef']
startswith()、endswith()判断字符串是否以括号内参数开头或结尾
swapcace()大小写转换
replace()将字符串中指定字符或字符串用指定字符或字符串代替
test1="alexalexalexalexalex"
v1=test1.replace("ex","bbb",2)#2代表替换次数
print(v1) 》》albbbalbbbalexalexalex
6个基本方法：
jion()、spilt()、find()、strip()、upper()、lower()、replace()
黑科技：
1.索引,下标，获取字符串中的某一个字符
test='alex'
v0=test[0]
v1=test[1]
v2=test[2]
v3=test[3]
print(v0，v1，v2，v3) 》》a
》》l
》》e
》》x #切片
v4=test[0:2]#表示从0到2，【0，2）前闭后开区间
print(v4) 》》al ############################
v5=len(test5)#获取当前字符串由几个字符组成
print(v5) 》》4
2.注：len()可用于其他数据类型，
li=[11,22,33,33] print(len(li))#返回列表长度，用逗号分割 》》4
3.for i in 循环结构
test="python真的好简单"
i=0
while i<len(test):
v=test[i]
print(v)
i+=1
print("#############")
》》p
y
t
h
o
n
真
的
好
简
单
############# for i in test:
print(i) 》》p
y
t
h
o
n
真
的
好
简
单
字符串一旦创建不可修改，一旦修改和拼接会在内存中重新创建新的字符串
3.布尔值 bool
4.列表 list
# list #类，列表
li = [1, 2, 9, "age", ["是正文", [19, 10]], 'wetrwe', True] # 通过list类创建的对象，li
# 1.列表的格式：中括号括起来
# 用“，”分割每个元素
# 2.列表中可嵌套任何类型：列表中的元素可以是数字，字符串，列表，布尔值...所有的都能放进去
# "集合"，内部放任何东西 # 3.索引取值
print(li[3])
# 4.切片取值，结果也是列表
print(li[0:-1]) # 5.for循环
for item in li:
print(item)
列表在内存中是按链表的方式存储的，列表中元素存储不连续，但每个元素所占内存都存储了下一个元素的坐标。所以列表元素与字符串元素不同，可以被修改
#链表，
li = [1, 2, 9, "age", ["是正文", [19, 10]], 'wetrwe', True]
# 6.列表元素修改
# 索引方式修改
li[1]=15649
print(li) >>>[1, 15649, 9, 'age', ['是正文', [19, 10]], 'wetrwe', True]
# 切片方式修改
li[1:3]=[120,90]
print(li) ################
#删除列表元素
del li[1]
print(li)
# 7.切片方式删除
del li[2:5]
print(li) ################
# 8.in 操作
li = [1, 2, 9, "age", ["是正文", [19, 10]], 'wetrwe', True]
v=120 in li
print(v) v1="是正文" in li[4]
print(v1)
>>>False
>>>True
9.利用索引取值
li = [1, 2, 9, "age", ["是正文", [19, 10]], 'wetrwe', True]
#取出"19"
v=li[4][1][0]
print(v)
10.字符串转换为列表
#将字符串转换成列表，本质上去字符串中每一个元素进行for循环添加到列表中
s="wqrksldkfl"
new_s=list(s)
print(new_s) >>>['w', 'q', 'r', 'k', 's', 'l', 'd', 'k', 'f', 'l']
#数字无法参与循环迭代，所以数字无法转换成列
11.将列表元素转换成字符串
#将列表元素转换成字符串
li=[11,22,33,"ww","rerd"] v1=str(li)#将整个列表转换成字符串，相当于'[11,22,33,"ww","rerd"]'
print(v1) >>>[11, 22, 33, 'ww', 'rerd'] v2=""
for i in li:
v2+=str(i)
print(v2) >>>112233wwrerd #若列表中元素只有字符串，则可以用jion()方法
li_01=["fffwe","wqrewqr"]
v3="".join(li_01)
print(v3) >>>fffwewqrewqr
基本方法：
1.append（）
#1.追加append()，在原来值后面追加
li=[11,22,1315,4]
v=li.append(5)#相当于什么都不是
print(v)
print(li) >>>None
>>>[11, 22, 1315, 4, 5] li.append("saf")
li.append(['wqeqw',12346])
print(li) >>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346]]
2.clear()清空列表
3.复制，拷贝copy()
4.count(value)计算元素出现的次数
#2.清空列表clear（）li.clear()print(li)
>>>[]
#3.拷贝，浅拷贝，copy()
s=li.copy()
print(s)
>>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346]]
#4.计算元素在列表中的个数count(Value)
c=li.count(11)
print(c) >>>1
5.extend(iterable)扩展原来的列表，扩展元素必须是可迭代对象（字符串，列表等）
#5.extend(iterable)扩展原来的列表，扩展元素必须是可迭代对象（字符串，列表等）
li.extend(["wqewqe",657])
print(li) >>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346], 'wqewqe', 657] 与append()的区别：
li.append(["wqewqe",657])
print(li) >>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346], ['wqewqe', 657]] ###################
li.extend("不得了")
print(li)
>>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346], '不', '得', '了']
li.append("不得了")
print(li)
>>>[11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346], '不得了']
6.index(Value,Start=None,End=None)
#6.index(Value,Start=None,End=None),根据值找索引
ind=li.index(22)
print(ind) >>>1
7.insert(index，p_object)在指定索引位置插入指定元素
#7.insert(index，p_object)在指定索引位置插入指定元素
li.insert(0,'rrr4')
print(li) >>>['rrr4', 11, 22, 1315, 4, 5, 'saf', ['wqeqw', 12346]]
8.pop(index)删除列表某个值（1.指定索引，2.默认是最后一个）并获取这个值
remove(Value)删除列表中的指定值，从左往右
ps：pop() 、 remove() 、 del list[0] 、del list[0:4] 、clear()
9.reverse()将当前列表反转
10.sort(key=None，reverse=False)，列表的排序，cmp，key 欠
li=[11,66,55,55,2,44]
li.sort()
print(li) >>>[2, 11, 44, 55, 55, 66] li.sort(reverse=True)
print(li) >>>[66, 55, 55, 44, 11, 2]
对象.方法，# li对象调用append方法
补充：列表创建后可以通过索引取值和修改值，字符串创建后可以通过索引取值但不可修改值
li=[11,22,33,44] li[0]=999 print(li) >>>[999,22,33,44] s="alexs" print(s[0]) >>>a
列表是有序的，元素可以被修改
5.元组 tuple
#相当于对列表的二次加工，元组元素不可被修改，不能增加或删除
#tuple 类
tu=(111,222,"alex",(11,22,33),[0,1,2,3],True,5s5）
书写格式#一般写元组的时候，推荐在最后加入“，”，便于与方法区分
s="asf32 5we"
li=["y5rty",""]
tu=("sgsdrrrt",['fff',456],526,) v0=list(s)
print(v0) v1=tuple(s)
print(v1) v2=tuple(li)
print(v2) v3=list(tu)
print(v3) v4=str(li)
print(v4) v5=str(tu)
print(v5) #列表转换为字符串，当列表中只含有字符串时
l=["wrerewr","ewrewr","esadsad"]
v6="".join(l)
print(v6) #元组转换为字符串，当元组中只含有字符串时
t=("ewrsgf","tryrty","",)
v7="_".join(t)
print(v7) >>>['a', 's', 'f', '3', '2', ' ', '5', 'w', 'e']
>>>('a', 's', 'f', '3', '2', ' ', '5', 'w', 'e')
>>>('y5rty', '52')
>>>['sgsdrrrt', ['fff', 456], 526]
>>>['y5rty', '52']
>>>('sgsdrrrt', ['fff', 456], 526)
>>>wrerewrewrewresadsad
>>>ewrsgf_tryrty_241
#元组转换为字符串，当元组中不仅仅含有字符串时
s1=""
for i in tu:
s1=s1+str(i)
print(s1) >>>sgsdrrrt['fff', 456]526
元组也是有序的，元组的一级元素不可修改/删除/增加，但里面嵌套的列表可修改
#元组是有序的
tu=(123,5456,"asldw",[(545,555,)],True,3,4)
#找出555元素
print(tu[3][0][1]) >>>555 #####################
#元组的一级元素不可修改/删除/增加，但里面嵌套的列表可修改
tu[3].append(567)
print(tu) >>>(123, 5456, 'asldw', [(545, 555), 567], True, 3, 4)
基本方法：
1.count（）获取指定元素在元组中出现的次数
2.index（）获取某个值的索引位置
6.字典 dict
#dict 类
1.字典的value可以是任何值
info={
"k1":"v1",#键值对
"k2":"v2"}
#字典的value可以是任何值
info1={
"k1":23,
"k2":True,
"k3":[11,22,22,{
'kk1':'vv1',
'kk2':'vv2',
'kk3':(44,55,)
}],
"k4":(34,54,6,)
}
print(info) >>>{'k1': 23, 'k2': True, 'k3': [11, 22, 22, {'kk1': 'vv1', 'kk2': 'vv2', 'kk3': (44, 55)}], 'k4': (34, 54, 6)}
2.列表和字典不能作为字典的key
#列表和字典不能作为字典的key
info2={
123:'erwer',
"k1":'rewr',
(33,44,):'ertd',
True:'fgf',
}
print(info2) >>>{123: 'erwer', 'k1': 'rewr', (33, 44): 'ertd', True: 'fgf'}
3.字典是无序的
4.可以根据索引输入字典键值key获取对应的值，不可通过切片查找，因为无序
#获取‘ertd’
v2=info2[(33,44,)]
print(v2) #获取'44'
v1=info1['k3'][3]['kk3'][0]
print(v1)
5.字典元素的删除
del info['k3'][3]['kk1'']
6.字典的for循环
#for循环
for item in info1:#默认获取key值
print(item) for item in info1.keys():
print(item) for item in info1.values():#获取value
print(item) for k,v in info1.items():#获取Key和value
print(k,v)
基本方法
1.clear()删除
2.copy()复制,浅复制
@staticmethod 静态方法，支持直接写类名后带“.”可执行该功能如dict.fromkeys
3.dict.fromkeys（）根据序列，创建字典，并指定统一的值
v=dict.fromkeys(["k1",123,""],12345)
print(v) >>>{'k1': 12345, 123: 12345, '': 12345}
4.get()
info={
"k1":"v1"
}
a=info.get("k1",456478)#45678为默认若取不到相应的键值则返回的值
print(a)
b=info.get("rewrwer","wqerqwr")#若不传入值，则默认返回None
print(b)
>>>v1
>>>wqerqwr
5.pop(k,d=None)，删除传入k值，返回当前删除的key值，当k不存在字典中时，返回d，默认为None
6.popitem()，删除字典中的值，返回键值对，默认返回元组类型，若k,v=popitem()，则返回两个值
a1=info.pop("k122",999)
print(a1)
print(info)
a2=info.popitem()
print(a2)
print(info)
a3,b3=info.popitem()
print(a3,b3)
print(info)
>>>999
>>>{'k1': 'v1', 'k2': 'v2'}
>>>('k2', 'v2')
>>>{'k1': 'v1'}
>>>k1 v1
>>>{}
7.setdefalt(k,d=None)在字典中设置值，若已存在，则获取当前key对应的值，若不存在则设置值并获取当前对应的值，
info={
"k1":"v1",
"k2":"v2"
}
a1=info.setdefault("k1",123)
print(info,a1)
a2=info.setdefault("rree",123)
print(info,a2)
>>>{'k1': 'v1', 'k2': 'v2'} v1
>>>{'k1': 'v1', 'k2': 'v2', 'rree': 123} 123
8.update(E=None,**F)***kwargs这种参数python将自动转换成相应的格式
info={
"k1":"v1",
"k2":"v2"
}
info.update({'k1':454,"k3":48478})
print(info)
info.update(k1=123,k3=48789,k4="erwr")
print(info)
>>>{'k1': 454, 'k2': 'v2', 'k3': 48478}
>>>{'k1': 123, 'k2': 'v2', 'k3': 48789, 'k4': 'erwr'}
总结
一、数字
int（）
二、字符串
replace/fin/jion/strip/startwith/spilt/upper/lower/format
例：
template="I am {name},age:{19}"
v=template.formate(**{"name":"alex","age":19})
print(v)
三、列表
append/extend/insert
索引、切片、循环
四、元组
索引、切片、循环
一级元素不能被修改增加删除
五、字典
get/update/keys/values/items
for，索引
例：in在字典的用法
dic={ "k1":"v1"}
v="k1"in dic
print(v)
六、布尔值
0 1
bool（）
0，None，“”，（），[ ]，{ }都是False，其余都是True
补充：
enumrate(object，)，为可迭代对象添加序号
li = [11,22,33]
for k,v in enumerate(li, 1):
print(k,v) >>>1 11
>>>2 22
>>>3 33