20 Mar 18
1. 补充其他数字类型 (了解) #‘数字类型’不是类型，是帮助理解的概念
a. 长整型
python3中没有长整型的概念；
python2中, num=2L type(num) => ‘long’
b. 复数
x=1-2j print(x.real) #取实部
print(x.imag) #取虚部
1.0
-2.0
2. 字符串_需要掌握的操作
#1. strip, lstrip, rstrip #作用于首尾两端，可连用，不改变原字符串
name = '*egon**'
print(name.strip('*'))
print(name.lstrip('*'))
print(name.rstrip('*'))
egon
egon**
*egon
#2. lower, upper
name='eGon'
print(name.lower())
print(name.upper())
egon
EGON
#3. startswith, endswith #判断
name='alex_AB'
print(name.endswith('ab'))
print(name.startswith('alex'))
False
True
#4. format的三种玩法
也可用%(s), 但%s不只针对字符串；format后元素数量可多余前面，%s必须前后对应，否则报错。
res0 = ‘%s%s%s’%(‘egon’,18,’male’)
res1 ='{}{}{}'.format('egon',18,'male') #{}为字符串的占位符
res2='{1}{0}{1}{1}{1}'.format('egon',18,'male') #{}中可放数字
res3='{name}{age}{sex}'.format(sex='male',name='egon',age=18) #{} 不依赖于顺序
print(res1,res2,res3)
egon18male 18egon181818 egon18male
#5. split, rsplit #默认分隔符是空格, 默认 max_split为-1(全分割)
name='root:x:0:0::/root:/bin/bash'
print(name.split(':'))
name='C:/a/b/c/d.txt'
print(name.split('/',2)) ## 等于1时可拿到顶级目录
name='a|b|c'
print(name.rsplit('|',1))
name.rsplit('|') == name.split('|') ## 默认 max_split为-1
['root', 'x', '0', '0', '', '/root', '/bin/bash'] ##注意：：的输出结果
['C:', 'a', 'b/c/d.txt']
['a|b', 'c']
#6 **join ##可迭代对象必须是字符串
join与split对应，join 传入的列表必须只包含字符串类型
‘ ’.join() # ‘‘=》以什么连接 （）=》只包含字符串的列表
tag=''
print(tag.join(['egon','say','hello','world']))
egonsayhelloworld
‘’.join[1,2,3] =》报错
#7 replace #默认全部替换
name='alex say: i have one tesla, my name is alex'
print(name.replace('alex','AB',3))
AB say: i have one tesla, my name is AB
*看到参数self，当不存在
#8 isdigit #可判断bytes和unicode类型，是最常用的用于判断字符是否为“数字”的方法；只判断bytes，unicode类型的整数字符串为真
age=input('>>: ')
print(age.isdigit())
True or False
age = 10
inp = input('>>: ').strip()
if inp.isdigit():
inp = int(inp)
if inp > age:
print('too big')
else:
print('输入非法数据')
3. 字符串的其他操作（了解）
#1. find, rfind, index, rindex, count
name='egon say hello'
print(name.find('o',1,3)) #顾头不顾尾，找到显示sub集的起始位置的索引, 不指定范围找第一个，找不到则返回-1不会报错
print(name.index('e',2,4)) #类似find，但找不到报错
print(name.count('e',1,3)) #顾头不顾尾，不指定范围查找所有
2
Traceback (most recent call last):
0
#2. center, ljust, rjust, zfill
name='egon'
print(name.center(30,'-'))
print(name.ljust(30,'*'))
print(name.rjust(30,'*'))
print(name.zfill(50)) #用0填充，默认右对齐
-------------egon-------------
egon**************************
**************************egon
0000000000000000000000000000000000000000000000egon
#3. expandtabs
name='egon hello'
print(name)
print(' ')
print(name.expandtabs(0)) #参数为tabsize，指空格数
print(name.expandtabs(1))
egon hello
egonhello
egon hello
=》 表tab，本质是空格，不同平台默认的空格数不一致
=》 表换行
#4. captalize, swapcase, title
msg='egon sAy hi'
print(msg.capitalize()) #首字母大写
print(msg.swapcase()) #大小写翻转
print(msg.title()) #单个单词的首字母大写
Egon say hi
EGON SaY HI
Egon Say Hi
#5. is数字类型
is数字类型是用来判断字符串的，字符串中数字有四种类型
*num1=b ‘4’ # bytes 字节
*num2=u ‘4’《=》‘4’ # unicode, python3中无需加u就是unicode
num3=‘四’ #中文数字
num4= ‘IV’#罗马数字
对isdigit： 1 True， 2 True， 3 False， 4 False #判断bytes和unicode的阿拉伯整数为真（数字）；是最为常用的is数字类型
对isdecimal: 1无， 2 True， 3 False， 4 False #只能判断unicode格式的阿拉伯整数为真（数字）
对 isnumeric：1无， 2 True， 3 True， 4 True # 能判断unicode，中文数字， 罗马数字格式的阿拉伯整数为真（数字）；可能会用到银行项目
#6. is 其他
print(name.isalpha()) #字符串只有字母组成
print(name.isalnum()) #字符串有字母或数字组成
print(name.isidentifier())
print(name.islower())
print(name.isupper())
print(name.isspace())
print(name.istitle())
4. 字符串的总结
存放一个值；有序（序列类型，能按照索引取值），不可变
#‘序列类型’不是一种类型，为方便理解
list有序， dict无序（不能按照索引取值）
5. 列表的基本使用
定义：中括号内可以有多个任意类型的值，逗号分隔
l2=list('hello')
print(l2)
l3=list(111)
print(l3)
['h', 'e', 'l', 'l', 'o'] #相当于for循环
Traceback (most recent call last): #报错
6. 列表优先掌握定的操作
#1 按索引存取值（正向存取+反向存取）；即可存也可取
l=['a','b','c']
print(l,id(l))
l[0]='A'
print(l,id(l))
['a', 'b', 'c'] 4367353032
['A', 'b', 'c'] 4367353032 #列表为可变类型，id不变， 不可通过索引加值，否则报错
#2 切片（顾头不顾尾，步长）
stus = ['alex','egon','wxx','yxx', 'lxx']
print(stus[1:3])
['egon', 'wxx'] #所取值依旧为列表
#3 长度
stus = ['alex','egon','wxx','yxx', 'lxx']
print(len(stus))
5 #列表中元素的个数
#4 成员运算in和not in
#5 追加
stus = ['alex','egon','wxx','yxx', 'lxx']
print(stus.append('ab')) #往后加值,一次加一个值
print(stus)
None
['alex', 'egon', 'wxx', 'yxx', 'lxx', 'ab']
插入：
stus = ['alex','egon','wxx','yxx', 'lxx']
print(stus.insert(1, 'ab')) #1为起始位置，insert一次加一个值
print(stus)
None
['alex', 'ab', 'egon', 'wxx', 'yxx', 'lxx']
#6 删除
del stus[1] #万能删除，不止针对列表
stus = ['alex','egon','wxx','yxx', 'lxx']
print(stus.remove('alex')) #remove只能按照成员删，按索引报错
print(stus)
print(stus.pop(1)) #按索引删，若不加参数，默认删掉末尾（默认参数为-1）
print(stus)
None #用remove删是单纯的删除，没有返回值
['egon', 'wxx', 'yxx', 'lxx']
wxx #用remove删，是取走/弹出一个值
['egon', 'yxx', 'lxx']
#7 循环
a. 依赖索引
i=0
stus = ['alex','egon','wxx','yxx', 'lxx']
while i <len(stus):
print(stus[i])
i+=1
for i in range(len(stus)):
print(i,stus[i])
b. 不依赖索引
stus = ['alex','egon','wxx','yxx', 'lxx']
for item in stus:
print(item)
7. 补充for循环
for i in range(1,5,2): #(起始，结束，步长)，顾头不顾尾
print(i) # 1 3
for i in range(10): #一个参数时，10默认是结束位置，起始位置默认为0
print(i) #0 1 2 …9
for i in range(10,-2,-1):
print(i) #10 9 8 …-1
stus=['alex','egon','wxx','yxx']
for i in range(len(stus)):
print(i,stus[i])
0 alex
1 egon
2 wxx
3 yxx
for循环中，break和continue依旧适用， 有for else用法
8. 列表需要掌握的操作
#1
stus=['alex','egon','wxx','yxx']
print(stus.clear()) #清空
print(stus)
None
[]
#2
stus=['alex','egon','wxx','yxx']
print(stus.copy()) #拷贝
print(stus)
['alex', 'egon', 'wxx', 'yxx']
['alex', 'egon', 'wxx', 'yxx']
#3
stus=['alex','egon','wxx','yxx']
print(stus.count('e')) #统计元素数量
print(stus)
0
['alex', 'egon', 'wxx', 'yxx']
#4
stus=['alex','egon','wxx','yxx']
print(stus.extend('alex')) #extend 可加多个值
print(stus)
None
['alex', 'egon', 'wxx', 'yxx', 'a', 'l', 'e', 'x']
#5
stus=['alex','egon','wxx','yxx']
print(stus.index('yxx',0,4)) #取元素的索引
print(stus)
3
['alex', 'egon', 'wxx', 'yxx']
#6
stus=['alex','egon','wxx','yxx']
print(stus.reverse()) #元素反写
print(stus)
None
['yxx', 'wxx', 'egon', 'alex']
#7
stus=['alex','egon','wxx','yxx']
print(stus.sort(reverse =True)) #正（反）向排序
print(stus)
None
['yxx', 'wxx', 'egon', 'alex']
注： __xx__ 为python的内置方法，当输入满足时，自动出现，不需调用
e.g.: print(len(stus)) # print(stus.__len__())
sort只针对纯数字或纯字母 [1,10, ‘a’].sort() 报错
字符串的比较是从第一个字符开始一个一个比较，且必须同时比较的两者属于一个类型（数字/字母），否则报错。A Z a z 从小到大
9. 队列（先进先出）
入队： l1.append(‘first’) ; l1.append(‘second’); l1.append(‘third’)
出队： l1.pop(0); l1.pop(0); l1.pop(0)
#思考用insert怎么实现
10.堆栈（先进后出，后进先出）
入栈：l1.append(‘first’) ; l1.append(‘second’); l1.append(‘third’)
出栈：l1.pop(); l1.pop(); l1.pop()
11.列表总结
可以存多个值，有序，可变