1.格式化输出
如果你想制作一个字符串类的模板，或者是想让字符串某些位置变成动态输入，此时你想到用字符串拼接，格式化输出。
% 占位符
数据类型： s 字符串 d 整数 f 浮点型 r 内置函数
第一种方式：交互输入根据每个位置以%站位传参
name = input('请输入您的名字：') age = input('请输入您的年龄：') job = input('请输入工作：') xingbie = input('请输入您的性别：') max = """ ---------------%s的个人简历----------------- 姓名： %s 年龄： %d 工作： %s 性别： %s -------------------end---------------------- """% (name, name, int(age), job, xingbie) print(max)
输出结果： 请输入您的名字：wk 请输入您的年龄：24 请输入工作：运维 请输入您的性别：男 ---------------wk的个人简历----------------- 姓名： wk 年龄： 24 工作： 运维 性别： 男 -------------------end----------------------
第二种方式：将字典传入，根据key取值
wk = {'name':'wk', 'age':24, 'work':'运维', 'xingbie':'男'}
max = """
---------------%(name)s的个人简历-----------------
姓名： %(name)s
年龄： %(age)d
工作： %(work)s
性别： %(xingbie)s
-------------------end----------------------
"""% wk
print(max)
输出结果：
---------------wk的个人简历-----------------
姓名： wk
年龄： 24
工作： 运维
性别： 男
-------------------end----------------------
在格式化输出中只想单纯的表示% 写%%
mas = '我叫%s，今年%d， 我的python学习进度为%d%%' % ('wk', 25, 5) print(mas) 我叫wk，今年25， 我的python学习进度为5%
2.运算符
算术运算： + - * / % ** //（加 减 乘 除 取余 平方 取整）
a = 10 b = 3 print(a%b) print(a**2) print(a//b) 结果： 1 取余为1 100 2次方 3 取整为3
比较运算： == != > < >= <=
赋值运算： += -= * / % **
逻辑运算：not and or （非 和 或）
优先级： not and or :同一优先级从左之后依次计算
print(3 > 2 and 3 < 4 or 5 > 6 and 2 < 5) # true or false 结果为： True
print(1 > 1 and 3 < 4 or 4 > 5 and 2 > 1 and 9 > 8 or 7 < 6) # false or false or false 结果为： false
逻辑运算两边都是数值
两个数字x和y做or运算（x or y）：如果x为True 则返回x，否则返回y。
两个数字x和y做and运算（x and y）：如果x为True 则返回y，否则返回x。（与or相反）
int bool之间的转换
int ---> bool:非零即True.
print(bool(100)) print(bool(0)) 结果： True False print(int(True)) print(int(False)) 结果 1 0
数字比较：
print(-10 or 3) print(0 or 3) print(1 and 3 or 4) print(0 and 3 or 5) 结果： -10 非0即True or返回左 3 0即False or 返回右 3 先算and 返回右 再算or返回左 5 先算and 返回左 再算or返回右
逻辑运算两边是数值或者比较
print(1 and 4 < 6 or 5) 先算and 后算or 4<6的值为True 所以结果为；True
成员运算:判断某些元素在不在一个序列中 str，tuple list dict set
in 在
not in 不在
s1 = 'asd' s3 = '12daa' s2 = 'asdqweqwewdsda'
s4 = 'ad' print(s1 in s2) #结果True print(s1 not in s3) #结果True
print(s1 in s4) #结果Fales
编码：
"北京烤鸭降价了"
对照表：密码本
0000001 北
0000100 京
0010110 烤
0010101 鸭
0010100 0101100 10101
ASCII:最早版本的'密码本'.
8位 == 1 个字节。
0000 0001 256可能，代表256个不同的字符。
ABC：
01000001 01000010 01000011
一个字符：1个字节表示。
'hello': 5个字节
万国码：Unicode，将世界上所有国家的文字都包含进来。
起初：16位 两个字节表示一个字符。
a: 01000001 01000001
中：01000101 01000001
升级：32位 四个字节表示一个字符。
a: 01000001 01000001 01000001 01000001
中：01000101 01000001 01000001 01000001
浪费资源，空间。
utf-8:最少用8位，一个字节表示一个字符。
a:01000001 一个字节
欧洲文字: 01000001 01000001 两个字节
亚洲 中 ：01000001 01000001 01000001 三个字节。
gbk: 国标，只包含ASCII，中文。
a: 01000001 一个字节
中:01000001 01000001 两个字节。
s1 = '老男boy'
# gbk 编码：7个字节。
# utf-8 编码：9个字节。
单位转换：
8bit == 1 bytes
1024bytes == 1 kb
1024kb == 1MB
1024MB = 1Gb
1024GB = 1TB
1024TB = 1PB
基础数据类型
int 整数型
计算十进制转化成二进制的有效位数
i = 10 print(i.bit_length()) 结果为： 4 # 转为2进制有4位有效位
bool 布尔值
True真 False假
#字符串转布尔值和数字转布尔值一样，非空即True s1 = 'wk' s2 = ' ' #空格也算非空 s3 = '' print(bool(s1)) print(bool(s2)) print(bool(s3)) 结果： True True False
str 字符串
索引及切片：
下标索引 （下标从0开始，根据下标找字符）
s1 = 'wk学习python' print(s1[1]) #取出第二位字符（从0开始 ）
print(s1[-1]) #-1取字符串最后一位 结果为： k
n
切片（顾头不顾尾）
格式：起始索引:结尾索引+1:步长
s1 = 'wk学习python' print(s1[2:4]) #取第2到第3个字符 print(s1[:2]) #取从开都到第1个字符 （开头为0，不写即从开头开始取） print(s1[:]) #取所有（不写即取所有） print(s1[::2]) #取所有步长为2,（从开头隔一个取一个值） print(s1[-1:-10:-1]) #反向取值必须加反向步长 结果： 学习 wk wk学习python w学pto nohtyp习学k
常用方法： 对字符串操作形成的都是新的字符串，与之前字符串没有关系
capitalize swapcase center upper lower startswith endswith title strip lstrip rstrip split rsplit join replace
s = 'wk' print(s.capitalize()) #capitalize()首字母大写 Wk
print(s.swapcase()) #swapcase()大小写反转，小写变大写，大写变小写 WK
print(s.center(10)) #center(10) 总长度设为10，原wk字符串居中 wk
print(s.center(10, '*')) #居中后将*设为填充物，填充空白字符 ****wk****
print(s.upper()) #upper()全部字母改为大写 WK
print(s.lower()) #lower()全部字母改为小写（用于验证码小写验证） wk
print(s.startswith('w')) #startswith()判断是否是以什么为开头,可以判断多个字符开头 True
print(s.startswith('k',1)) #判断第1个字符是否是k True
print(s.endswith('k')) #判断是以什么字符结尾 True
s1 = 'wk xixi2hehe*tmd' print(s1.title()) #title()非字母隔开的单词首字母大写 Wk Xixi2Hehe*Tmd
s2 = ' \nwk\t' print(s2.strip()) #strip()默认去除字符串两端的空格，制表符，换行符，常用在登录系统 wk
s3 = 'wkcysndd' print(s3.strip('dkwd')) #从后从前依次匹配字符并去除，遇到阻挡字符即停止 cysn
print(s3.lstrip('dkwd')) #lstrip()只去除左边的 cysndd
print(s3.rstrip('dkwd')) #rstrip()只去除右边的 wkcysn
s4 = 'wk cy ls' print(s4.split()) #split()将字符自动分割为列表（默认是按空格分割）有几个分隔符，分割出来的字符an分隔符+1 str -list ['wk', 'cy', 'ls']
s5 = 'wk.cy.ls' print(s5.split('.')) #指定分割符分割 ['wk', 'cy', 'ls']
print(s5.split(',',1)) #指定以，分割且只分割1次 ['wk', 'cy,ls']
print(s5.rsplit(',',1)) #rsplit()从右往左分割，只分割1次 ['wk,cy', 'ls']
print('*'.join(s3)) #'字符'.join() 以任意字符为分隔符 分割字符串的每个字符 w*k*c*y*s*n*d*d
l1 = ['wk', 'cy', 'ls'] print(''.join(l1)) #将列表转换为字符串“前提为列表内容只能是字符串，不能有int或bool” wkcyls
print(s5.replace('wk', 'python',1)) #replace()将s5的wk替换为python替换一次，默认全部替换 python,cy,ls
is系列
wk = 'wk123' print(wk.isalnum()) #判断字符串是由字母或数字组成 True print(wk.isalpha()) #判断字符串只由字母组成 False print(wk.isdigit()) #判断字符串只由数字组成 （可作为str转换int的一个判断条件） False
format格式化输出
wk = '{} {} {}'.format('wk', '25', 'man') print(wk) wk 25 man print('{1}{0}{1}'.format('wk', '25', 'man')) #下标输出 25wk25 print('{name}{age}{xingbie}'.format(name='wk', age='25', xingbie='man')) #变量名输出 wk25man
公共方法 （在列表也能用）len（字符串长度）和count（单个元素出现次数）
wk = 'werwqrfdfsafas rwqerasf' print(len(wk)) #输出字符串长度 23 print(wk.count('f')) #输出一个元素在字符串里出现了几次，括号里可写起始位置和结束位置 4
find和index 通过元素找索引
区别：find通过元素找索引找不到返回-1，index通过元素找索引找不到报错
wk = 'werwqrfdfsafas rwqerasf' print(wk.find('q')) 4 print(wk.index(d)) 7
模拟验证码登录验证程序：
user = input('请输入账号') passwd = input('请输入密码') yanzheng = input('请输入验证码').upper() yzm = 'DddwWsA'.upper() if user == 'wk' and passwd == '123': if yanzheng == yzm: print('登录成功') 结果： 请输入账号wk 请输入密码123 请输入验证码dddwwsa 登录成功
数据之间的转换
int()
bool()
str()
列表
list基础数据类型，以括号隔起来，每个元素以逗号隔开，是容器类数据类型. 可以存储各种数据类型，可以存储各种数据类型，可以存储大量的数据.
列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。
索引切片（与字符串一样）
l1 = ['wk', 'xixi', 100, '嘻嘻', '女神'] print(l1[:3])
['wk', 'xixi', 100]
增删改查以及其他操作
增 append inster extend
l1 = ['wk', 'xixi', 100, '嘻嘻', '女神'] l1.append('666') #追加 l1.insert(1, 520) #插入到第1个位置 l1.extend('abc') #迭代追加，将字符串拆成最小单位 l1.extend(['abc', 'def']) #将列表追加 print(l1) ['wk', 520, 'xixi', 100, '嘻嘻', '女神', '666', 'a', 'b', 'c', 'abc', 'def']
删pop remove clear del
l1 = ['wk', 'xixi', 100, '嘻嘻', '女神'] l1.pop(1) #pop按下标删并有返回值，返回值为别删除的字符 print(l1) ['wk', 100, '嘻嘻', '女神'] l1.remove('wk') #remove按元素删除，没有返回值 print(l1) [100, '嘻嘻', '女神'] l1.clear() #clear清空列表 print(l1) [] l1 = ['wk', 'xixi', 100, '嘻嘻', '女神'] del l1[2] #del按下标删 print(l1) ['wk', 'xixi', '嘻嘻', '女神'] del l1[:2] #del切片删 print(l1) ['嘻嘻', '女神'] del l1[::2] #del隔一个删一个 print(l1) ['女神']
改 安索引改和按照切片改
l1 = ['wk', 'xixi', 100, '嘻嘻', '女神'] l1[1] = 'heihei' #按下标改 print(l1) ['wk', 'heihei', 100, '嘻嘻', '女神'] l1[:2] = '21312312' #按切片改 print(l1) ['2', '1', '3', '1', '2', '3', '1', '2', 100, '嘻嘻', '女神'] l1 = ['wk', 'xixi', 100, '嘻嘻', '女神'] l1[::2] = 'abc' #按步长改（有多少个改的值对应多少字符） print(l1) ['a', 'xixi', 'b', '嘻嘻', 'c']
查
l1 = ['wk', 'xixi', 100, '嘻嘻', '女神'] for i in l1: print(i)
其他方法
l1 = ['wk', 'xixi', 100, '嘻嘻', '女神'] print(l1.index('xixi')) #index通过元素查索引 1 print(len(l1)) #查看元素总个数 5 print(l1.count('wk')) #查单个元素个数 1 l1 = [2, 32, 1, 31, 13, 43, 45, 65] l1.reverse() #翻转排序 print(l1) [65, 45, 43, 13, 31, 1, 32, 2] l1.sort() #从小到大排序 print(l1) [1, 2, 13, 31, 32, 43, 45, 65] l1.sort(reverse=True) #从大到小排序 print(l1) [65, 45, 43, 32, 31, 13, 2, 1]
range 自定义的数字范围的列表，一般都是与for循环结合。
for i in range(4): print(i) 0 1 2 3 for i in range(1,6,2): #切片加步长 print(i) 1 3 5 for i in range(5,-1,-1): #倒序 print(i) 5 4 3 2 1 0
元组tuple(用于不能被修改的重要数据)
元组是只读列表。可以索引，可以切片（步长）。不能增删改（儿子不能，孙子有可能），只能查询。
tu = (1, True, [12, 3], 'wk') print(tu[1]) True tu[2][1] = 4 #可对元组里的列表进行修改 print(tu) (1, True, [12, 4], 'wk')
字典dic
键值对出现，Key:value 字典的key唯一不重复，可以存储大量的关系型数据。 字典3.5版本包括3.5之前是无序的。3.6之后有序。字典的key：str,int,（bool值，tuple不常用） 不可变的数据类型(可哈希的).字典的value：任意数据类型。
增
dic = {'name': 'wk', 'age': 25, 'sex': '男'}
dic['job'] = '运维'
print(dic)
{'name': 'wk', 'age': 25, 'sex': '男', 'job': '运维'}
dic['name'] = 'wkk'
print(dic)
{'name': 'wkk', 'age': 25, 'sex': '男', 'job': '运维'}
dic.setdefault('哎呀','妈呀') #只能用于添加,如果已有对应的key则不做改变
print(dic)
{'name': 'wkk', 'age': 25, 'sex': '男', 'job': '运维', '哎呀': '妈呀'}
删pop del clear
dic = {'name': 'wk', 'age': 25, 'sex': '男'}
dic.pop('name') #pop根据key删,有返回值
print(dic)
{'age': 25, 'sex': '男'}
del dic['age'] #del 根据key删,无返回值
print(dic)
{'sex': '男'}
dic.clear() #clear清空字典
print(dic)
{}
改 update
dic = {'name': 'wk', 'age': 25, 'sex': '男'}
dic['name'] = 'wkk' #根据key修改
print(dic)
{'name': 'wkk', 'age': 25, 'sex': '男'}
dic2 = {'name': '嘻嘻', 'weight': 75}
dic2.update(dic) #将dic的所有键值对覆盖并添加到dic2中.dic不变
print(dic)
{'name': 'wkk', 'age': 25, 'sex': '男'}
print(dic2)
{'name': 'wkk', 'weight': 75, 'age': 25, 'sex': '男'}
查 get keys values
dic = {'name': 'wk', 'age': 25, 'sex': '男'}
print(dic['name']) #直接根据key查看值,如果key不存在则报错(不常用)
wk
print(dic.get('name')) #用get 取出key对应的值,如果没有key不报错
wk
print(dic.get('name1', '没有此键')) #用get取出对应的值并设置一个返回值,如果没有对应的key则返回没有此键
没有此键
print(dic.keys()) #取出所有的key
dict_keys(['name', 'age', 'sex'])
print(dic.values()) #取出所有的values
dict_values(['wk', 25, '男'])
分别赋值
dic = {'name': 'wk', 'age': 25, 'sex': '男'}
print(dic.items()) #items 将key和值变为对应的元组
dict_items([('name', 'wk'), ('age', 25), ('sex', '男')])
a,b = 1,2
print(a)
1
print(b)
2
for k,v in dic.items():
print(k,v)
name wk
age 25
sex 男
字典嵌套及取值
dic = {'name': 'wk',
'name_list': ['ww', 'kk'],
1:{'name': '小小'},
'age': 25, 'sex': '男'}
print(dic['name_list'][0].upper()) #将ww改为大写
WW
dic[1]['name'] = 'xiaoxiao' #将1里的key的值改为xiaoxiao
print(dic)
{'name': 'wk', 'name_list': ['ww', 'kk'], 1: {'name': 'xiaoxiao'}, 'age': 25, 'sex': '男'}
基础数据类型补充
元组:元组中如果只有一个元素且没有逗号，则他不是元组而是该元素对应的类型。
tu = (1) #不加逗号则为int类型 print(tu, type(tu)) 1 <class 'int'> tu1 = (1,) #加逗号为元组 print(tu1, type(tu1)) (1,) <class 'tuple'> tu2 = ('adsad') #字符串不加逗号为字符串 print(tu2, type(tu2)) adsad <class 'str'> tu3 = ([1,2,3]) #列表不加逗号为列表 print(tu3, type(tu3)) [1, 2, 3] <class 'list'>
dict 创建字典的一种方式
dic = dict.fromkeys('123', 'wk') print(dic) {'1': 'wk', '2': 'wk', '3': 'wk'}
== 比较的是两边的数值是否相同
is 比较的是内存地址是否相同
id 查询的是内存地址
s1 = 'wk' s2 = 'wk' print(s1 == s2) True print(s1 is s2) True print(id(s1)) 31375968
在 正向 循环一个list中，如果改变的列表的大小，那么结果是随着循环删除改变的
正向循环删除基数下标位的值,结果报错,因为每循环删除一次,列表位置会发生变化,因此需要倒序删除,则不会有变化 l1 = [11, 22, 33, 44, 55, 66] for i in range(len(l1)): if i %2 ==1: l1.pow(i) print(l1)
#倒序删除 l1 = [11, 22, 33, 44, 55, 66] for i in range(len(l1)-1,-1,-1): #len(l1) =6 ,但下标为0,1,2,3,4,5 因此倒序为5,4,3,2,1 len(l1)-1=5 顾头不顾尾-1为0 最后-1为倒序排列 if i % 2 ==1: #判断下标除以2取余数为1的为奇数 l1.pop(i) print(l1) [11, 33, 55]
在循环一个字典时，不能改变该字典的大小。
删除字典dic = {'k1':'v1','k2':'v2','k3':'v3','name': 'alex'} 含有k的key
错误做法:(在循环时改变了字典的大小) dic = {'k1':'v1','k2':'v2','k3':'v3','name': 'alex'} for i in dic: #循环时改变了dic的大小报错 if 'k' in i: del dic[i] print(dic) 报错
dic = {'k1':'v1','k2':'v2','k3':'v3','name': 'alex'}
l1 = [] #定义一个空列表
for i in dic: #循环dic的key
if 'k' in i: #判断字符是否有k
l1.append(i) #如果有将判断出的key添加到列表内
for i in l1: #只循环l1,未循环字典
del dic[i] #删除字典里的key
print(dic)
集合
集合里的元素必须是不可变的数据类型
集合是无序的,
{1, '嘻嘻', 'int'}
集合本身是可变的,但是要求里边的数据是不可变的.
集合拥有天然的去重功能.
可能用到的地方:
1.列表去重
s1 = [1, 1, 2, 2, 3, 4, 4, 4] s2 = set(s1) #将列表转为集合,集合自带去重 s3 = list(s2) #再将集合转为列表 print(s3) #打印列表 [1, 2, 3, 4]
2.关系测试 (交集,并集,差集)
交集 & 或 intersection() 并集 | 或 union() 差集 - 或 difference()
s1 = {5, 1, 3, 2, 4}
s2 = {3, 4, 5, 6, 7}
print(s1 & s2) #交集
{3, 4, 5}
print(s1.intersection(s2))
{3, 4, 5}
print(s1 | s2) #并集
{1, 2, 3, 4, 5, 6, 7}
print(s1.union(s2))
{1, 2, 3, 4, 5, 6, 7}
print(s1 - s2) #差集
{1, 2}
print(s1.difference(s2) )
{1, 2}
