python语法入门到面向过程编程（二）
类型总结
一：整形基本使用（int）
1 int用途:年龄 号码 等级…
2 定义方式
age=10 age=int(10)
x=int(‘1111’) int只能将纯数字的字符串转成十进制的整型
print(type(x))
3 整形常用操作+内置的方法
算数运算（+、—、*、/）,比较运算（>,<,>=,<=,!=）
二：整形总结
1 存一个值or存多个值?
只能存一个值
2 有序or无序?
没有有序无序这么一说
3 可变or不可变
可变不可变类型总结:
可变指的是改变原值,即在原值基础上进行修改
可变类型的底层原理:在id不变的情况下,值可以改变
不可变类型的底层原理:值改变,id也跟着变
int是不可变数据类型
age=10
print(id(age))
age=11
print(id(age))
长整型Long,只有在python2中才有长整型号
复数complex
x=1-2j
print(x.real)
print(x.imag)
print(type(x))
一：浮点型基本使用（float）
1 用途:薪资 身高 体重
2 定义方式
salary=3.1 salary=float(3.1)
n=float('3.1')
3 常用操作
算数运算 比较运算
二：该类型总结
1 存一个值or存多个值
只能存一个值
2 有序or无序
没有有序无序这么一说
3 可变or不可变
float是不可变类型
x=3.1
print(id(x))
x=3.2
print(id(x))
一：字符串基本使用（str）
1 用途: 描述性质的数据,比如人的名字,单个爱好,地址
2 定义方式
name='ycf' name=str('ycf')
x=str(1)
y=str(1.1)
z=str([1,2,3])
n=str({'y':1})
print(type(x))
print(type(y))
print(type(z))
print(type(n))
3 常用操作+内置的方法
优先掌握的操作(*****)：
1、按索引取值(正向取+反向取) ：只能取
msg=‘hello world’
print(type(msg[5]))
print(msg[-1])
msg[2]=‘A’
2、切片(顾头不顾尾，步长)
msg='hello world'
print(msg[1:5],type(msg[1:5]))
print(msg[6:-1])
print(msg[6:11])
print(msg[6:])
print(msg[6::2])
print(msg[0:])
print(msg[::-1])
msg='hello world'
print(msg[-3:-6:-1])
print(msg[6:9:-1])
3、长度len
msg='hello world'
print(len(msg))
4、成员运算in和not in
print(‘SB’ in ‘my name is xxx,xxx is SB’)
print(‘xxx’ in ‘my name is xxx,xxx is SB’)
print(‘xxx’ not in ‘my name is xxx,xxx is SB’) 推荐
print(not ‘xxx’ in ‘my name is xxx,xxx is SB’)
5、移除空白strip
name=' x xxx '
print(name.strip(' '))
print(name.strip())
name='****A*xxx*xxx****'
print(name.strip('*'))
name='****xxx****'
print(name.lstrip('*'))
print(name.rstrip('*'))
pwd=input('>>: ').strip() pwd='123 '
if pwd == '123':
print('login successful')
msg='cccabcdefgccccc'
print(msg.strip('c'))
print('*-=xxx*&^'.strip('-= *&^'))
6、切分split
msg='xxx:18:male:180:160'
l=msg.split(':')
print(l)
print(l[3])
7、循环
msg='hello world'
for x in msg:
print(x)
需要掌握
1、strip,lstrip,rstrip
2、lower,upper
name='EoN'
print(name.lower())
name='xxxxN'
print(name.upper())
3、startswith,endswith
print('xxxis SB'.startswith('xx'))
print('xxxis SB'.endswith('B'))
4、format的三种玩法
print('my name is %s my age is %s' %('xxx',18))
print('my name is {name} my age is {age}'.format(age=18,name='xxx')) 可以打破位置的限制,但仍能指名道姓地为指定的参数传值
print('my name is {} my age is {}'.format('xxx',18))
print('my name is {0} my age is {1} {1} {1} {1}'.format('xxx',18))
5、split,rsplit
info='xxx:18:male'
print(info.split(':',1))
print(info.split(':',1)) ['xxx','18:male']
print(info.rsplit(':',1)) ['xxx:18','male']
6、join:只能将元素全为字符串的列表拼成一个大的字符串
info='xxx:18:male'
l=info.split(':')
print(l)
new_info='-'.join(l)
print(new_info)
num=['a','b','c']
':'.join(num) 'a'+':'+'b'+':'+'c'
num=[1,2,'c']
':'.join(num) 1+':'+2+':'+'c'
7、replace
msg='my name is xxx,xxxis SB'
print(msg.replace('xxx','Pig',1))
print(msg)
8、isdigit
print('111.1'.isdigit())
print('1111'.isdigit())
AGE=73
age=input('>>: ').strip() age='asdfasdf'
if age.isdigit():
age=int(age)
if age > AGE:
print('too big')
elif age < AGE:
print('too small')
else:
print('you got it')
else:
print('必须输入数字啊傻叉')
1、find,rfind,index,rindex,count
msg='my name is xxx,xxxis hahaha'
print(msg.find('xxx'))
print(msg.find('SB')) 找不到会返回-1
print(msg.index('xxx'))
print(msg.index('SB')) 找不到index会报错
print(msg.find('xxx',0,3))
print(msg.count('xxx'))
print(msg.count('xxx',0,15))
2、center,ljust,rjust,zfill
print('info xxx'.center(50,'-'))
print('info xxx'.ljust(50,'-'))
print('info xxx'.rjust(50,'-'))
print('info xxx'.zfill(50))
3、expandtabs
print('a\tb\tc'.expandtabs(1))
4、captalize,swapcase,title
print('my name is xxx'.capitalize())
print('my Name Is xxx'.swapcase())
print('my name is xxx'.title())
5、is数字系列
num1=b'4' bytes
num2=u'4' unicode,python3中无需加u就是unicode
num3='壹' 中文数字
num4='Ⅳ' 罗马数字
isdigit():bytes,unicode
print(num1.isdigit())
print(num2.isdigit())
print(num3.isdigit())
print(num4.isdigit())
isdecimal():unicode
print(num2.isdecimal())
print(num3.isdecimal())
print(num4.isdecimal())
isnumberic;unicode,中文,罗马
print(num2.isnumeric())
print(num3.isnumeric())
print(num4.isnumeric())
6、is其他
print('abasdf123123'.isalnum())
print('asdfasdf'.isalpha())
print('xxx'.islower())
print('xxx'.isupper())
print(' '.isspace())
print('My Name Is Xxx'.istitle())
二：该类型总结
1 存一个值or存多个值
只能存一个值
2 有序or无序
有序
3 可变or不可变
不可变
name='xxx'
print(id(name))
name='yyy'
print(id(name))
作用：多个装备，多个爱好，多门课程，多个女朋友等
定义：[]内可以有多个任意类型的值，逗号分隔
my_girl_friends=['xxx','yyy','zzz',4,5] 本质my_girl_friends=list([...])
l=list('hello') list内只能跟能够被for循环遍历的数据类型
print(l)
l=list({'a':1,'b':2})
print(l)
1、按索引存取值(正向存取+反向存取)：即可存也可以取
names=['xxx','wxx','lxx','yyy']
names[0]='XXX'
print(names)
2、切片(顾头不顾尾，步长)
names=['xxx','wxx','lxx','yyy']
print(names[0:3])
3、长度
names=['xxx','wxx','lxx','yyy']
print(len(names))
4、成员运算in和not in
names=['xxx','wxx','lxx','yyy',4]
print(4 in names)
5、追加
names=['xxx','wxx','lxx','yyy']
names.append('cxx1')
names.append('cxx2')
names.append('cxx3')
print(names)
6、删除
names=['xxx','wxx','lxx','yyy']
del names[2]
print(names)
7、循环
names=['xxx','wxx','lxx','yyy']
for name in names:
print(name)
names=['xxx','wxx','lxx','yyy',4,3.1]
names.insert(1,'SB')
print(names)
names=['xxx','wxx','lxx','yyy',4,3.1]
res=names.remove('wxx') 单纯的删掉,是按照元素的值去删除，没有返回值
print(res)
print(names)
names=['xxx','wxx','lxx','yyy',4,3.1]
res=names.pop(1) 拿走一个值,是按照索引去删除,有返回值
print(names)
print(res)
names=['xxx','wxx','lxx','yyy',4,3.1]
print(names.pop())
print(names.pop())
names=['xxx','wxx','lxx','lxx','yyy',4,3.1]
print(names.count('lxx'))
print(names.index('lxx'))
names.clear()
print(names)
x=names.copy()
print(x)
names.extend([1,2,3])
print(names)
names.reverse()
print(names)
names=[1,10,-3,11]
names.sort(reverse=True)
print(names)
二：该类型总结
1 存一个值or存多个值
可以存多个值，值都可以是任意数据类型
2 有序or无序
有序
3 可变or不可变
可变
l=['a','b']
print(id(l))
l[0]='A'
print(id(l))
元组，字典，列表
队列：先进先出
l=[]
入队
l.append('111')
l.append('222')
l.append('333')
出队
print(l.pop(0))
print(l.pop(0))
print(l.pop(0))
堆栈：先进后出
l=[]
入栈
l.append('111')
l.append('222')
l.append('333'))
出栈
print(l.pop())
print(l.pop())
print(l.pop())
一：基本使用
1 用途：用来存多个值，但每一个值都有一个key与之对应，key对值有描述性的功能
当存储多个值表示的不同的状态时，
2 定义方式:{}内用逗号分隔开多个元素，每一个元素都是key：value的形式
value可以是任意数据类型，但是key必须为不可变类型，key通常应该是字符串类型，
d={'x':1,'y':2} d=dict({'x':1,'y':2})
d=dict(a=1,b=2,c=3)
print(d)
dic={1:'a',0:'b',1.1:'c',(1,2,3):'d'}
print(dic[1])
print(dic[0])
print(dic[1.1])
print(dic[(1,2,3)])
dic={[1,2,3]:'a'}
dic={{'x':1}:'a'}
3 常用操作+内置的方法
优先掌握的操作：
1、按key存取值：可存可取
d={'x':1,'y':2}
d['x']=100
print(d)
d['z']=3
print(d)
l=['a','b']
l[2]='c'
2、长度len
d={'x':1,'y':2}
print(len(d))
3、成员运算in和not in
d={'x':1,'y':2}
print('x' in d)
4、删除
d={'x':1,'y':2}
del d['x']
print(d)
res=d.pop('y')
print(d)
print(res)
res=d.popitem()
print(d)
print(res)
d={'a':1,'b':2,'c':3,'d':4}
for k in d:
print(k)
l=[1,2,3]
del l[1]
print(l)
5、键keys()，值values()，键值对items()
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
names=[]
for k in msg_dic:
names.append(k)
print(names)
values=[]
for k in msg_dic:
values.append(msg_dic[k])
print(values)
keys=msg_dic.keys()
print(keys)
for k in keys:
print(k)=
l=list(keys)
print(l)
vals=msg_dic.values()
print(vals)
print(list(vals))
print(msg_dic.items())
print(list(msg_dic.items()))
6、循环
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
只取key
for k in msg_dic:
print(k,msg_dic[k])
for k in msg_dic.keys():
print(k,msg_dic[k])
只取value
for v in msg_dic.values():
print(v)
取key和value
for k,v in msg_dic.items(): k,v=('apple', 10)
print(k,v)
d={'x':1,'y':2,'z':3}
v=d.get('xxxx')
print(v)
print(d['xxxxxxx'])
d={'x':1,'y':2,'z':3}
d1={'a':1,'x':1111111}
d.update(d1)
print(d)
l=['name','age','sex']
d={}
for k in l:
d[k]=None
d=dict.fromkeys(1,None)
print(d)
info.setdefault
info={'name':'xxx','age':18,'sex':'male'}
如果字典中有setdefault指定的key，那么不改该key对应的值，返回原的value
res=info.setdefault('name','xxx_NB')
print(info)
print(res)
如果字典中没有setdefault指定的key，那么增加一个key:value,返回新的value
info.setdefault('height',1.80)
print(info)
info={'age':18,'sex':'male'}
v=info.setdefault('name','yyy')
print(v)
s='hello zzz xxx say hello sb sb'
l=s.split()
print(l)
d={}
for word in l: word= 'hello'
if word not in d:
d[word]=1 {'hello':2, 'xxx':1,'say':1}
else:
d[word]+=1
print(d)
s='hello xxx xxx say hello sb sb'
l=s.split()
print(l)
d={}
d={'hello':2,'xxx':2}
for word in l: word='xxx'
d[word]=l.count(word) d['xxx']=2
d.setdefault(word,l.count(word))
print(d)
二：该类型总结
1 存一个值or存多个值
可以存多个值，值都可以是任意类型，而key必须是不可变类型，通常应该是不可变类型中字符串类型
2 有序or无序
无序
3 可变or不可变
d={'x':1,'y':2}
print(id(d))
d['x']=1111
print(id(d))
一：基本使用
1 用途：元组是不可变的列表，能存多个值，但多个值只有取的需求，而没有改的需求，那么用元组合最合理
2 定义方式:在()内用逗号分割开，可以存放任意类型的值
names=('xxx','yyy','wxx') names=tuple(('xxx','yyy','wxx'))
print(type(names))
强调: 当元组内只有一个元素时，务必记住加一个逗号
x=('xxx',)
print(type(x))
3 常用操作+内置的方法
1、按索引取值(正向取+反向取)：只能取
names=('xxx','yyy','wxx')
names[0]='sb'
2、切片(顾头不顾尾，步长)
names=('xxx','yyy','wxx','lxx','cxxx')
print(names[1:3])
3、长度
names=('xxx','yyy','wxx','lxx','cxxx')
print(len(names))
4、成员运算in和not in
names=('xxx','yyy','wxx','lxx','cxxx')
print('xxx' in names)
5、循环
names=('xxx','yyy','wxx','lxx','cxxx')
for item in names:
print(item)
二：该类型总结
1 存一个值or存多个值
可以存多个值，值都可以是任意数据类型
2 有序or无序
有序
3 可变or不可变
不可变
names=('xxx','yyy','wxx','lxx','cxxx')
del names[0]
names[0]='sb'
print(names.count('lxx'))
print(names.index('wxx',0,3))
names=('xxx','yyy','wxx','lxx','cxxx')
names=1
l=[1,243,3]
l=3333
l=['a','b','c']
print(id(l[0]))
l[0]='A'
print(id(l[0]))
names=('a','b','c')
列表可变的底层原理：
指的是索引所对应的值的内存地址是可以改变的
元组不可变的底层原理：
指的是索引所对应的值的内存地址是不可以改变的
或者反过来说，只要索引对应值的内存地址没有改变，那么元组始终是没有改变的
```bash
t1 = (['a', 'b', 'c'], 'wc', 'office')
print(id(t1[0]))
print(id(t1[1]))
print(id(t1[2]))
t1[0][0] = 'AAAA'
print(t1)
print(id(t1[0]))
集合
一：基本使用
1 用途: 关系运算、去重
2 定义方式:{}内用逗号分隔开多个元素，每一个元素都必须是不可变（即可hash）类型
强调：
2.1 集合内元素都必须是不可变（即可hash）类型
2.2 集合内的元素无序
2.3 集合内的元素不能重复
s={1,2,'a'} s=set({1,2,'a'})
print(type(s))
s={1.1,1,'aa',(1,2,3),{'a':1}}
s={1,'a','hello',(1,2,3),4}
for item in s:
print(item)
s={1,1,1,1,1,1,1,1,1,'a','b','a'}
s={(1,2,3),(1,2,3),'a','b','a'}
print(s)
s=set('hello')
print(s)
单纯的用集合去重，需要注意的问题是
1、去重的目标所包含的值必须都为不可变类型
2、去重的结果会打乱原来的顺序
names=['asb','asb','asb','wsb','wsb','isetan_nb',[1,2,3]]
s=set(names)
names=list(s)
print(names)
3 常用操作+内置的方法
优先掌握的操作：
1、长度len
pythoners={'王大炮','李二丫','陈独秀','牛铁蛋','wxx','李二蛋'}
print(len(pythoners))
2、成员运算in和not in
print('李二丫' in pythoners)
pythoners={'王大炮','李二丫','陈独秀','牛铁蛋','wxx','李二蛋'}
linuxers={'陈独秀','wxx','isetan','张全蛋'}
3、|并集
print(pythoners | linuxers)
print(pythoners.union(linuxers))
4、&交集
print(pythoners & linuxers)
print(pythoners.intersection(linuxers))
print(linuxers & pythoners)
5、-差集
print(pythoners - linuxers)
print(pythoners.difference(linuxers))
print(linuxers - pythoners)
print(linuxers.difference(pythoners))
6、^对称差集
pythoners={'王大炮','李二丫','陈独秀','牛铁蛋','wxx','李二蛋'}
linuxers={'wxx','isetan','张全蛋'}
print(pythoners ^ linuxers)
print(pythoners.symmetric_difference(linuxers))
print(linuxers ^ pythoners)
7、==
s1={1,2,3}
s2={1,2,3}
print(s1 == s2)
8、父集(包含关系)：>,>=
s1={1,2,3,4,5}
s2={1,2,3}
print(s1 > s2) s1包含s2
print(s1.issuperset(s2))
print(s2.issubset(s1))
s3={1,2,10}
print(s1 > s3)
s1={1,2,3,4,5}
s2={1,2,3,4,5}
print(s1 >= s2)
9、子集(被包含的关系)：<,<=
s1={1,2,3,4,5}
s1.add(6)
print(s1)
s1.update({4,7,8,9})
print(s1)
res=s1.pop()
print(res)
res=s1.remove(4)
print(res)
print(s1)
s1={1,2,3,4,5}
s2={2,3,7,8}
s1=s1 - s2
print(s1)
s1.difference_update(s2) s1=s1 - s2
print(s1)
s1={1,2,3,4,5}
s1.pop()
s1.remove(7)
s1.discard(7) 即便要删除的元素不存在也不会报错
s1={1,2,3,4,5}
s2={6,7}
print(s1.isdisjoint(s2))无交集部分
二：该类型总结
1 存一个值or存多个值
可以存多个值，值都必须为不可变类型
2 有序or无序
无序
3 可变or不可变
set集合是可变类型
s={1,2,3}
print(id(s))
s.add(4)
print(s)
print(id(s))
=集合的去重======
单纯的用集合去重，需要注意的问题是
1、去重的目标所包含的值必须都为不可变类型
2、去重的结果会打乱原来的顺序
names=['asb','asb','asb','wsb','wsb','isetan_nb',[1,2,3]]
s=set(names)
names=list(s)
print(names)
stu_info=[
{'name':'isetan','age':18,'sex':'male'},
{'name':'isetan','age':18,'sex':'male'},
{'name':'isetan','age':18,'sex':'male'},
{'name':'axxxx','age':73,'sex':'male'},
{'name':'yyyyyy','age':84,'sex':'female'},
]
new_info=[]
for info in stu_info:
if info not in new_info:
new_info.append(info)
print(new_info)