潭州课堂25班：Ph201805201 第二课：数据类型和序列类型 (课堂笔记)

workon py3env

pip install ipython   安装虚拟环境，

安装完成之后，键入：ipython   进入环境，

数字类型：（整型）   int    -------->>1  2  3 ..

　　　　　　　　主要方法：

　　　　　　　　a = ''

　　　　　　　　b = int ( a )　  将字符串转为数字类型，默认为 10 进制 base = 10

　　　　　　　　c = 'a'

　　　　　　　　d = int ( c, base = 16 )　将字符串转为 16 进制 数字  base = 2 为2进制　　　　　　　　

　　　　　　　　age = 5
　　　　　　　　v = age.bit_length()　　　 当前数字的二进制，至少用几位表示，
　　　　　　　　print( v )

　　　　　（浮点型）float -------->>0.1   1.1 ..　

　　　　　（布尔型）bool -------->>  True(1),  False(0)

　　　　　　　假：　　None,  "", (),  [],  {},   0 ------>>>  False

　　　　　　　真：除了假都是真的，

　　　　　（复数）    complex -------->>  5j,  123j,   00j

精确运算：导入模块  import decimal

decimal. Decimal ('0.1') + decimal. Decimal ('1.1')

//  向下取整，

向上取整， import math

　　　　　math.ceil( 5/2 )

%  取余

x = x+1  ----->>>   x += 1

x = x-1   ------->>  x -= 1

序列类型：

　　　　（字符串）  str   ------>>   ''    ""    ''' '''　　　　　　a = 'abc'

　　　　　　　　　　主要方法：

　　　　　　a = ' abc '

　　　　　　b = a.capitalize()　　b 得到的值 首字母大写
　　　　　　b = a.casefold()　　　b 得到的值 统一大小与　　（特殊字符）
　　　　
　　　　设置宽度用内容填充

　　　　　　b = a.center(10)　　　一共 10 个位，把 abc 放中间

　　　　　　b = a.center(10, '*')　　　一共 10 个位，把 abc 放中间 空白处用 * 填充
　　　　　　b = a.ljust(15，'*')　　打印： abcdef*********
　　　　　　b = a.rjust(15,'*')　　打印： *********abcdef

　　　　计算字符出现的次数，

　　　　　　b = a.count('a')　　从第几个位开始找   a.count('a', 3)
　　　　　　可以设起始位，结束位，a.count('a' ,3, 5)

　　　　　　b = a.encode()
　　　　　　b = a.decode()

　　　　　　b = a.endswith(c)　　以什么结尾，是则为真，否则返回假，
　　　　　　b = a.startswith()　　以什么开头，是则为真，否则返回假，

　　　　　　b = a.find('a')     从开始往后找，找到第一个，返回他下标，
　　　　　　可以设查找的起始位和结束位，没有则返回 -1  b = a.find('a', 2, 4)

　　　　　　b = a.index('a')　　　与 find 的用法一样，但其在查找时如果没找到，将报错，

　　　　　　格式化，将字符串中占位的符 {} 替换成指定的值
　　　　　　format  输写格式
　　　　　　a = 'i am {name} ,age={ a }'
　　　　　　b = a.format( name='斌彬', a=20 )
　　　　　　print(b)　　---->>>   i am 斌彬, age = 20

　　　　　　a = 'i am {}, age = {}'
　　　　　　b = a.format( '斌彬', 20
　　　　　　print(b)　　---->>>   i am 斌彬, age = 20

　　　　　　　t = 'i am {name},age:{age}'
　　　　　　　v = t.format( **{'name':'binbin','age': 19} )

 　　　　　　format_map 输写格式 转入字典 　　　　　　
　　　　　　　a = 'i am {name}, age = {a}'　　　　
 　　　　　　b = a.format_map( {'name':'斌彬','a':20 } ) 　　　　　　
　　　　　　　　print(b)　　---->>> i am 斌彬, age = 20 　　　　　　
　　　　　　　　b = a.isalnum() 判断是否只包含字母和数字，是返回真，否返回假（有其他字符） 　　　　　　
　　　　　　　　b = a.isalpha()　　　判断是否只包含字母，是返回真，否返回假 　　　　　　
　　　　　　　　b = a.isdigit()　　　判断是否只包含数字，是返回真，否返回假　　　　(常用) 　　　　　　
　　　　　　　　b = a.isdecimal()　　　判断是否只包含数字，是返回真，否返回假 　　　　　　
　　　　　　　　b = a.isnumeric()　　　判断是否只包含数字，是返回真，否返回假　　（支持中文） 　　　　　　
　　　　　　　　b = a.islower()　　　判断是否小写，是返回真，否返回假 　　　　　　
　　　　　　　　b = a.isupper() 　　判断是否大写，是返回真，否返回假 　　　　　　
　　　　　　　b = a.lower()　　　　转换成小写 　　　　　　b = a.upper() 转成大写 　　　　　　
　　　　　　　　b = a.isprintable()　　　判断是否能打印的字串，如内包含（\t,\n..）则返回 False 　　　　　　
　　　　　　　　b = a.isspace()　　　判断是否全空格，是否是空字符串 　　　　　　
　　　　　　　　b = a.istitle()　　　判断是否首字母大写 　　　　　　
　　　　　　　　a = 'abcdef' 　　　　　　b = ' '.join(a) 　　　　　　
　　　　　　　　print( a ) 以 .join 前面‘’的为参数，将 a 拼接 　　　　　　　　a b c d e f 　　　　　　
　　　　　　　　a = 'abcdef' 　　　　　　c = '01234' 　　　　　　b = ''.join( (a,c) ) 　　　　　　
　　　　　　　　print(b)　　　　　　　　将两个以上的字符串拼接， 等同于 + 的操作 　　　　　　　　abcdef01234 　　　　
　　　　　　　　b = a.strip()　　去空格 （两边） 去除（\t,\n..） 在（）可写要去除的参数
 　　　　　　b = a.lstrip()
 　　　　　　b = a.rstrip()
 　　　　　　b = a.split()　　　　分割 在（）内写入参数，按其进行分割，可有第二个参数，表示分割次数，
 　　　　　　b = a.lstrip() 　　　　　　b = a.rstrip() 　　　　　　
　　　　　　 b = a.splitlines()　　根据换行符 \n 分割，在（）内参数如果是 True 显示| \n, 如果是 False 不显示 \n
 　　　　　　b = a.partition('a')　　　　只分割三次

　　　　　　a = 'abcdaef'　　
　　　　　　b = a.replace('a','x',1)　　　替换，把参数1，换成参数2，可设替换次数，

　　　　　　b = a.startswith()　　　判断是否以（参数）开头，是返回真，否返回假，
 　　　　　 b = a.endswith()　　　　判断是否以（参数）结尾，是返回真，否返回假，
 　　　　 　b = a.swapcase()　　　　大写换小写，小写换大写， 　　
　　　　
　　　　　　断句，根据 expandtabs() 内的值找
 　　　　　 s = 'username\temail\tbinbin\tbinbin@qq.com\nusername\temail\tbinbin\tbinbin@qq.com\nusername\temail\tbinbin\tbinbin@qq.com\n'
 　　　　　　v = s.expandtabs(15)
 　　　　　　print(v)　　可以打印出类似一个表格的样子，
 　　　　　　　　　　username email binbin binbin@qq.com
 　　　　　　　　　　username email binbin binbin@qq.com
 　　　　　　　　　　username email binbin binbin@qq.com

　　　　（列表）      list   ------>>   [   ]    多个元素用，号隔开，

　　　　　　　　　　主要方法：

　　　　d = [1,2,3,4,5,6]
　　　　del  d[0]　　　　 根据索引删除
　　　　del d[0：5]　　　　　　　　　　　　　　（切片）
　　　　d.pop()　　　　　　弹出，默认量后一个，可根据索引指定弹出，　　（删除并返回该值）
　　　　d.remcve( 列表中的元素 )
　　　　d.clear()　　　　　　　清空

　　　　d[1:3] = [15.22] 根据索引进行修改   （切片）
　　　　x =  6 in d 　　　　　　支持 in 操作 返回真给 x
　　　　for         循环

　　　　d = [1,2,3,['a',['pe','q'],'m'], 4,5,6]
　　　　a = d[3][1][0][1]    索引取值
　　　　print(a)------》》e  　　　

　　　　list(  )　　　　　　　转为列表 数字不可以直接转

　　　　d = [ 'a','b','c''d' ]
　　　　news = ''.join(d)　　 列表转为字符串，  （列表中只有字符串）

　　　　d = [ 'a','b',1,2,3 ]
　　　　s = ''
　　　　for i in d:　　　　　　列表转字符串，  （列表中有数字）
　　　　    s = s + str(i)

　　　　d.append(添加的值)　　追加
　　　　v = copy()　　　　　　浅拷贝 给 v
　　　　d.count( 列表中的元素 )　　统计元素在列表中的个数，
　　　　d.append( ‘a’ )　　　　　　　　追加
　　　　d.extned( 参数是个 iterable 对象 )  添加 可迭代的对象
　　　　d.index( 列表元素 )      找该元素的索引值，　可设 查找范围 的起始位和结束位 
　　　　d.insert( 索引，值 )　　　　指定位插入，
　　　　d.reverse()　　　　　　倒序
　　　　d.sort()   　　　　　　从小到大排列
　　　　d.sort( reverse = True ) 　　　　　　从小到大排列

　　　　（元祖）  tuple   ------>>  (   )   多个元素用，号隔开，，里边只有一个元素是，要加，号  ( 1, )

　　　　　　　　　　　　　　　　主要方法：（列表的二次加工，不可修改，不可增加）  与参数区分，在后面加，号

　　　　　　tu = ( 'a','b',1,2,3 ,)
　　　　　　v = su[0]　　　　　　　　索引取值，
　　　　　　v = su[0:3]　　　　　　　切片取值
　　　　　　for　　　　　　　　　　　　支持，
　　　　　　tuple 转 str 同 list 转 str 同样方法，
　　　　　　但是：
　　　　　　　　tu = ( 'a',[1,3,4,5],1,2,3 ,)  元祖中的列表可以被 增删改 的相关操作，

　　　　　　tu.count( 元祖中的元素 )　　统计元素在元祖中的个数，
　　　　　　tu.index( 元祖元素 )      找该元素的索引值，　可设 查找范围 的起始位和结束位 

type 函数： type （）查看类型

索引取值：

　　　　st1 = 'asdfsadf'

　　　　st1 [ index ]　　　　st1 [0]          st1 [3] ...

　　　　st1 [ -1]　　倒着数，第一个　　

切片：

　　st1 [  start : end ; stap  ]　　　　st1 [  开始: 结束 ; 步长  ]

类型转换：.....

id ()   查内存地址

拆包：

　　x, y, z =( 1, 2, 3 )

　　x = 1,  y = 2,  z = 3

　　x, *y =  (1, 2, 3 )

　　x = 1,  y = [ 2,  3]

成员运算：

　　　　in 判断是否存在，是返回 True,  否返回 False

　　　　not in 判断是否不存在，是返回 False,  否返回 True

　　　　

注：橙底白字为必记部分，

for k,v in enumerate( 迭代参数 , 1):  第二个参数表示从 1 开始加序号，默认从 0 开始
　　　print ( k,v )　　　　　　给迭代出来的值加序号

di = {1:2,2:3,4:1,5:5}
for i,v in enumerate(di.items(),1):
    print(i,v)

1 (1, 2)
2 (2, 3)
3 (4, 1)
4 (5, 5)

di = {1: 2, 2: 3, 4: 1, 5: 5}
for i, v in enumerate(di.items(), 1):
    print(i,v[0],v[1])

1 1 2
2 2 3
3 4 1
4 5 5