Day02

Posted 2020-10-31 rainbow91

上周内容回顾

解释型：

     当程序运行的时候，逐行解释，逐行执行。

     c

编译型：

     一次性全部把所有的代码编译成二进制。

 

变量：a=‘alex‘

常量：一直不变的量，全部大写，放在py文件的最上面。

 

注释：#

          ‘‘‘ ‘‘‘     """ """

基础数据类型：

int 数字运算

     str 字符串，少量的数据存储

     + 拼接；str * int

     python凡是用引号引起来的就是字符串

     

bool：True     False

 

input 用户交互，他出来的全部是字符串类型

格式化输出     % d s f

 

运算符：

     + - * / %

     逻辑运算符：

     () > not > and > or

     同一优先级，从左至右依次计算

     x or y if x True，return x

 

if:

 

if:

     pass

 

if 条件:

     pass

else:

     pass

 

if 条件:

     pass

elif 条件:

     pass

elif 条件:

     pass

else:

     pass

 

if 条件:

     if 条件:

          pass

          if...

 

while True:

     pass

 

跳出循环：

1、改变条件；

2、break。

 

continue：跳出本次循环，继续下次循环。

 

while 条件:

     pass

else:

     pass

当while被打断走else

 

for 变量 in 可迭代对象:

     pass

 

for 变量 in 可迭代对象:

     pass

else:

     pass

 

编码：

     ascii：字母、数字、特殊字符。

     万国码：unicode：

                         A：两个字节16位     0000 0010 0000 0010

                         中：两个字节

     万国码升级：

                         A：四个字节16位     0000 0010 0000 0010 0000 0010 0000 0010

                         中：四个字节

                         占空间，浪费资源。

     utf-8：最少用一个字节，表示一个字符

          A：0000 0010     一个字节

          欧洲：000 0010 0000 0010     两个字节

          中文：000 0010 0000 0010 000 0010     三个字节

     gbk国标：

          A：0000 0010     一个字节

          中：0000 0010 0000 0010     两个字节

 

作业讲解

     

---

 

01     int

     1,2,3... 用户计算，运算

     

i = 3
print(i.bit_length())

转化二进制最小位数

 

02     str

     ‘老男孩‘，‘alex‘ ... 少量的数据存储

 

     int ---> str     str(int)

     str ---> str     int(str) str必须为数字

 

     int ---> bool    0 False 非零 True

     bool ---> int     int(True) 1  int(False) 0

 

     str ---> bool     ‘‘ 空字符串 false     非空字符串 True

 

     #字符串是有索引的

     s[起始索引:结束索引+1:步长]

     s = ‘python自动化运维21期‘

     s1=s[0]

     print (s1)

     p

     s3 = s[-1]

     print (s3)

     期

     #切片     顾头不顾腚

     s1 = s[0:6] #如果前面是0，0可以不写 s1 = s[:6]

     print(s1)

     python

     s2 = s[6:9]

     print(s2)

     自动化

     #跳切 步长

     s3 = s[:5:2]

     print(s3)

     pto

     #取全部

     s4 = s[:]

     print(s4)

     #倒取 必须加反向步长

     s5 = s[-1:-5:-1]

     print(s5)

     

     s = ‘oldBoy‘

     #1 * capitalize() 首字母大写

     s1 = s.

 

     #2 *** upper() 全部大写     lower() 全部小写

     code = ‘QeAr‘.upper()

     your_code = input(‘请输入验证码：‘).upper()

     if your_code == code:

          print(‘验证成功‘)

 

     #3 * s.swapcase() 大小写反转

     s = ‘oldBoy‘

     s4 = s.swapcase()

     print(s4)

 

     #4 * s.title() 非字母隔开的每个单词首字母大写

     s = ‘alex wusir*old‘

     

     #5  s.center 居中，长度自己设定，默认填充物是None

     s6 =s.center(30,"*")

     print(s6)

 

     #6 *** s.startswith() 以xxx为开头 s.endswith()

     s = ‘oldBoy‘

     s7 = s.startswith(‘o‘)

     print(s7)

     True

     s = ‘oldBoy‘

     s7 = s.startswith(‘ol‘)

     print(s7)

     True

     s = ‘oldBoy‘

     s7 = s.startswith(‘B‘,3,5)

     print(s7)

     True

 

     #7 *** s.strip() 去除收尾空格，制表符\\t，换行符，但不仅仅

     s = ‘      oldBoy     ‘

     s8 = s.strip()

     print(s8)

     oldBoy

 

     s = ‘\\toldBoy\\n‘

     s8 = s.strip()

     print(s8)

     oldBoy

 

     name = input(‘>>>‘).strip()

     if name == ‘oldboy‘:

          print(‘验证成功‘)

     

     s = ‘tyoldBoyrte‘

     s81 = s.strip(‘t‘)

     print(s81)

     s81 = s.strip(‘tey‘)

     print(81)

     oldBoyr

     s.sltrip s.srtrip

     #8 **** split()  (str ---> list) 默认用空格隔开

     s = ‘oldboy wusir alex‘

     l = s.split()

     print(l)

     [‘oldboy‘,‘wusir‘,‘alex‘]

 

     s = ‘oldboy,wusir,alex‘

     l = s.split(‘,‘)

     print(l)

     [‘oldboy‘,‘wusir‘,‘alex‘]

 

     s = ‘oldboywusiroalex‘

     l = s.split(‘o‘)

     print(l)

     [‘‘,‘ldb‘,‘ywusir‘,‘alex‘]

 

     #可设置切割次数

     s = ‘oldboywusiroalex‘

     l = s.split(‘o‘,1)

     print(l)

     [‘‘,‘ldboywusiroalex‘]

 

     #9 join()

     s = ‘oldBoy‘

     s9 = ‘+‘.join(s)

     print(s9)

     o+l+d+B+o+y

     将list转换为str，但非字符串元素不可用

     l1 = [‘oldboy‘,‘wusir,‘alex‘‘]

     s91 = ‘_‘.join(l1)

     print(91)

     oldboy_wusir_alex

     

     #10 replace()替换

     s = ‘大铁锤fdsalj铁锤妹妹范德萨‘

     s10 = s.replace(‘铁锤‘,‘钢蛋‘)

     print(s10)

     大钢蛋fdsalj钢蛋妹妹范德萨

     

     #11 find() 通过元素找索引，找不到返回-1     index() 找不到会报错

     s = ‘oldBoy‘

     ind = s.find(‘d‘)

     print(ind)

     2

 

     s = ‘oldBoy‘

     ind = s.find(‘o‘)

     print(ind)

     0

 

     s = ‘oldBoy‘

     ind = s.find(‘A‘)

     print(ind)

     -1

 

     #12 公共方法 len() count()

     s = ‘asdaksjdkajskdajlk‘

     print(len(s))

     18

 

     s = ‘fdsadd‘

     print(s.count(‘d‘))

     3

 

     #13 格式化输出format

     res = ‘我叫{}今年{},爱好{}‘.format(‘agon‘,‘18‘,‘male‘)

     print(res)

     

     

     res = ‘我叫{0}今年{1},爱好{2},我依然叫{0}‘.format(‘agon‘,‘18‘,‘male‘)

     print(res)

     

     res = ‘{}‘

 

     #14 is系列

     name=‘jinxin123‘print(name.isalnum()) #字符串由字母或数字组成

     print(name.isalpha()) #字符串只由字母组成

     print(name.isdigit()) #字符串只由数字组成

     i = ‘123a‘

     if i.isdigit():

          i = int(i)

     else:

          print("输入有误。。。")

 

03     bool

     True/False     条件：for while if

 

04     list   列表  可以放各种类型   大量数据  32位上亿个数据

     [True,1,‘alex‘,{‘name‘:‘oldboy‘},[1,2,3],(2,3,4),{‘wusir‘}]

 

     li = [111,‘alex‘,222,‘wusir‘]

     print(li[1])     #alex

     print(li[-1]     #wusir

     print(li[:2])     #[111,‘alex‘]

     print(li[:3:2])

 

     #增 删 改 查

     l = [‘老男孩‘,‘alex‘,‘wusir‘,‘taibai‘,‘ritian‘]

   #1、增    

     # append 在最后追加

     l.append(‘葫芦‘)

     l.append([1,2,3])

     print(l)

     [‘老男孩‘, ‘alex‘, ‘wusir‘, ‘taibai‘, ‘ritian‘, [111, 222]]

 

     #insert 插入

     l.insert(1,‘景nvshen‘)

     print(l)

     [‘老男孩‘, ‘景nvshen‘, ‘alex‘, ‘wusir‘, ‘taibai‘, ‘ritian‘]

 

     #extend 迭代添加

     l.extend(‘alex‘)

     print(l)

     [‘老男孩‘, ‘alex‘, ‘wusir‘, ‘taibai‘, ‘ritian‘, ‘a‘, ‘l‘, ‘e‘, ‘x‘]

     l.extend([‘111‘,222,333])

     print(l)

     [‘老男孩‘, ‘alex‘, ‘wusir‘, ‘taibai‘, ‘ritian‘, ‘111‘, 222, 333]

 

     #2、删

     #pop 有返回值，按照索引删除

     print(l.pop(0))

     print(l)

     [‘alex‘, ‘wusir‘, ‘taibai‘, ‘ritian‘]

 

     #remove     按照元素删除

     l.remove(‘alex‘)

     print(l)

     [‘老男孩‘, ‘wusir‘, ‘taibai‘, ‘ritian‘]

 

     #clear     清空列表

     l.clear()

     print(l)

     []

 

     #del 内存级别删除列表

     del l

     print(l) #报错，l在内存里不存在

          #del 按索引删除

          del l[1]

          print(l)

          [‘老男孩‘, ‘wusir‘, ‘taibai‘, ‘ritian‘]

 

          #del 切片删除

          del l[:3]

          print(l)

          [‘taibai‘, ‘ritian‘]

 

     #3、改

     #按照索引改

     l[2] = ‘武藤兰‘

     print(l)

     [‘老男孩‘, ‘alex‘, ‘武藤兰‘, ‘taibai‘, ‘ritian‘]

 

     #按照切片改 

     l[1:3] = [111,222,333,444]

     print(l)

     [‘老男孩‘, 111, 222, 333, 444, ‘taibai‘, ‘ritian‘]

 

     #4、查

     #按索引去查,按照切片去查询

     for i in l:

          print(i)

 

     #其它方法：

     l1 = [1,2,1,2,1,1,3,4]

 

     #count 计数

     print(l1.count(1))

 

     #len

     print(len(l1))

 

     #通过元素找索引

     print(l1.index(2))

 

     #sort 列表排序

     l2 = [3,2,4,6,9,8,7,1]

     l2.sort()     #从小到大

     print(l2)

     l2.sort(reverse=True)     #从大到小

     print(l2)

 

     #reverse 

     l2.reverse()

     print(l2)

 

     #列表的嵌套

     l1 = [1,2,‘alex‘,‘wusir‘,[‘oldboy‘,‘ritian‘,10],‘taibai‘]

     #1，将‘alex‘全部变成大写，放回原处

     l1[2] = ‘ALEX‘

     l1[2] = l1[2].upper()

 

     #2，给[‘oldboy‘,‘ritian‘,10]追加一个元素‘女神‘。一个方法

     l1[-2].append(‘女神‘)

     print(l1)

 

     #3，将‘ritian‘首字母大写，放回原处

     l1[-2][1] = ‘Ritian‘

     l1[-2][1] = l1[-2][1].capitalize()

 

     #4，将99通过数字相加，或者字符串相加或者等等，变成‘100’

     l1[-2][-1] = str(l1[-2][-1] + 90)

     l1[-2][-1] = str(l1[-2][-1]) + ‘0‘

     print(l1)

 

05     tuple 元组：只读列表 不可增删改，

     (True,1,‘alex‘,{‘name‘:‘oldboy‘},[1,2,3],(2,3,4),{‘wusir‘})

     

     tu = (11,2,True,[2,3,4],‘alex‘)

     

     for i in tu:

          print(i)

          print(tu[1])

          print(tu[:3:2])

          print(tu.index(True))

          print(tu.count(2))

          print(tu.index(True))

 

     tu[-2].append(666)

     print(tu)

 

06     dict 字典 可储存大量数据，关系型数据。查询速度非常快，符合二分查找（字典的键key是唯一的，key必须是不可变的数据类型（可哈希）：str，bool，tuple，数字；value：任意数据类型）

     引伸：

     数据类型分类：

          不可变的数据类型（可哈希）：str，bool，tuple，int

          可变的数据类型：dict，list，set

          容器类数据类型：list，tuple，dict，set

 

     #3.6版本之前无序的，3.6版本之后是有序的

     {‘name‘:‘oldboy‘,‘age‘:45,‘name_list‘:[‘张三‘,‘李四‘,‘...‘]}

     

     dic = {‘name‘:‘taibai‘,‘age‘:21,‘hobby‘:‘girl‘}

 

     #增

     dic[‘high‘] 有则覆盖，无则添加

     dic[‘high‘] = 180

     print(dic)

     {‘name‘: ‘taibai‘, ‘age‘: 21, ‘hobby‘: ‘girl‘, ‘high‘: 180}

     dic[‘name‘] = ‘ritian‘

     print(dic)

     {‘name‘: ‘ritian‘, ‘age‘: 21, ‘hobby‘: ‘girl‘}

     

     dic.setdefault(‘high‘,180)

     print(dic)

     {‘name‘: ‘taibai‘, ‘age‘: 21, ‘hobby‘: ‘girl‘, ‘high‘: 180}

 

     #删

     pop #有返回值 是对应的值

     dic.pop(‘name‘)

     print(dic)

     {‘age‘:21,‘hobby‘:‘girl‘}

     小功能：如果删除的没有的情况不报错

     dic.pop(‘name1‘,None)     #返回值None自定义

     print(dic)

 

     clear #清空

     dic.clear()

     print(dic)

     {}

 

     del

     del dic

     print(dict) #报错

 

     del dic[‘name‘]

     print(dict)

     {‘age‘: 21, ‘hobby‘: ‘girl‘}

 

     dic.popitem()     #随机删除，有返回值 3.6版本之后删除最后一个

     print(dict)

     {‘name‘: ‘taibai‘, ‘age‘: 21}

 

     #改

     #直接覆盖

     dic[‘name‘] = ‘老男孩‘

     #dic2.update(dic) 更新

     dic = {"name":"jin","age":18,"sex":"male"}

     dic2 = {"name":"alex","weight":75}

     dic2.update(dic) # 将dic所有的键值对覆盖添加（相同的覆盖，没有的添加）到dic2中

     print(dic)

     {‘name‘: ‘jin‘, ‘age‘: 18, ‘sex‘: ‘male‘}

     print(dic2)

     {‘name‘: ‘jin‘, ‘weight‘: 75, ‘age‘: 18, ‘sex‘: ‘male‘}

 

     #查

     #键值查

     print(dic[‘name‘])

 

     #dic.get()

     print(dic.get(‘name1‘,‘没有此key‘))

 

     #循环查

     keys() values() items()

     print(list(dic.keys()))

     for i in dic.key():

          print(i)

 

     print(list(dic.values()))

     for i in dic.values ():

          print(i)

 

     print(list(dic.items()))

     for i in dic.items ():

          print(i)

 

     #分别赋值

     a,b =1,2

     a,b,c = [‘alex‘,‘wusir‘,‘ritian‘]

     a = 1

     b = 5

     ab值互换

     a,b = b,a

 

     for k,v in dic.items():

          print(k,v)

 

     #len

     print(len(dic))

 

     #fromkeys 创建字典

     dic1 = dict.fromkeys(‘abc‘,‘张三‘)

     print(dic1)

     {‘a‘: ‘张三‘, ‘b‘: ‘张三‘, ‘c‘: ‘张三‘}

     dic2 = dict.fromkeys([1,2,3],‘李四‘)

     print(dic2)

     {1: ‘李四‘, 2: ‘李四‘, 3: ‘李四‘}

     dic3 = dict.fromkeys(‘abc‘,[]) 指向相同地址，修改一个列表

     print(dic3)

     {‘a‘: [], ‘b‘: [], ‘c‘: []}

     

课堂练习

dic = {

  ‘name_list‘:[‘b哥‘, ‘张帝‘, ‘人帅‘, ‘kitty‘],

  ‘老男孩‘:{

  ‘name‘:‘老男孩‘,

  ‘age‘: 46,

  ‘sex‘: ‘ladyboy‘,

  },

}

#1,[‘b哥‘, ‘张帝‘, ‘人帅‘, ‘kitty‘]追加一个元素，‘骑兵‘

dic[‘name_list‘].append(‘骑兵‘)
print(dic)

#2，将kitty全部变成大写。

dic[‘name_list‘][-1] = dic[‘name_list‘][-1].upper()
print(dic)

#3，将老男孩 改成oldboy。

dic[‘老男孩‘][‘name‘] = ‘oldboy‘
print(dic)

#4，将ladyboy首字母大写。

dic[‘老男孩‘][‘sex‘] = dic[‘老男孩‘][‘sex‘].capitalize()
print(dic)

 

07     set     关系型数据的交集、并集、差集、子集... ... 而且可列表去重

     集合：

          无序，不重复的数据类型。他里面的元素必须是可哈希的。但是集合本身是可变的（不可哈希的）

          存在的意义：

               1）关系测试。交集并集，子集，差集

               2）去重（列表的去重）

 

     set1 = {1,‘alex‘,False,(1,2,3)}

     l1 = [1,1,2,2,3,3,4,5,6,6]

     set2 = list(set(l1))

     print(set2)

     [1, 2, 3, 4, 5, 6]

 

     #增

     set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}

     set1.add(‘景女神‘)

     print(set1)

 

     #update：迭代着增加

     set1.update(‘A‘)

     print(set1)

     set1.update(‘老师‘)

     print(set1)

     set1.update([1,2,3])

     print(set1)

 

     #删

     set1 = {‘alex‘,‘wusir‘,‘ritian‘,‘egon‘,‘barry‘}

 

     set1.remove(‘alex‘) # 删除一个元素print(set1)

 

     set1.pop() # 随机删除一个元素print(set1)

 

     set1.clear() # 清空集合print(set1)

 

     del set1 # 删除集合print(set1)

 

 

     #交集

     set1 = {1,2,3,4,5}

     set2 = {4,5,6,7,8}

     print(set1 & set2) # {4, 5}

     

     #并集

     print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8}

 

     #差集

     print(set1 - set2) # {1, 2, 3}

 

     #反交集

     print(set1 ^ set2) # {1, 2, 3, 6, 7, 8}

 

     #子集与超集

     set1 = {1,2,3}

     set2 = {1,2,3,4,5,6}

 

     print(set1 < set2)

     print(set1.issubset(set2)) # 这两个相同，都是说明set1是set2子集。

 

     print(set2 > set1)

     print(set2.issuperset(set1)) # 这两个相同，都是说明set2是set1超集。

 

     #frozenset 冻集合，不可变集合

     s = frozenset(‘barry‘)

     print(s,type(s)) # frozenset({‘a‘, ‘y‘, ‘b‘, ‘r‘}) <class ‘frozenset‘>

 

08     bytes类型

     #对于英文

     s = ‘laonanhai‘

     print(s,type(s))

 

     s1 = b‘laonanhai‘

     print(s1,type(s1))

 

 

 

 

09     编码

     ascii：字母、数字、特殊字符。

     万国码：unicode：

                         A：两个字节16位     0000 0010 0000 0010

                         中：两个字节

     万国码升级：

                         A：四个字节16位     0000 0010 0000 0010 0000 0010 0000 0010

                         中：四个字节

                         占空间，浪费资源。

     utf-8：最少用一个字节，表示一个字符

          A：0000 0010     一个字节

          欧洲：000 0010 0000 0010     两个字节

          中文：000 0010 0000 0010 000 0010     三个字节

     gbk国标：

          A：0000 0010     一个字节

          中：0000 0010 0000 0010     两个字节

     

     python3x：

     1）不同编码质检的二进制是不能互相识别的。

     2）python3x str内部编码方式（内存）为unicode

          但是，对于文件的存储和传输不能用unicode（占位多，流量大）

     bytes类型：内部编码方式（内存）为非unicode

     #对于英文

          str

          s = ‘laonanhai‘表现形式

          内部编码方式 unicode

 

          bytes：

          s1 = b‘laonanhai‘ bytes 表现形式

          内部编码方式 非unicode

     

     #对于中文：

          str

          s = ‘中国‘

          print(s,type(s)

          十六进制

     

 

 

     #转化

     s = ‘laonanhai‘

     s2 = s.encode(‘utf-8‘)     #str --> bytes encode 编码

     s3 = s.encode(‘gbk‘)

     print(s2,s3)

 

     s = ‘中国‘

     s2 = s.encode(‘utf-8‘)     #str --> bytes encode 编码

     s3 = s.encode(‘gbk‘)

     print(s2) #utf-8 三个字节

     print(s3) #两个字节

 

     s = ‘中国‘

     s2 = s.encode(‘utf-8‘)     #str --> bytes encode 编码

     ss = s2.decode(‘utf-8‘)     #bytes --> str decode 解码

     print(ss)

 

 

10     数据类型的补充

     l1 = [‘alex‘,‘wusir‘,‘taibai‘,‘barry‘,‘老男孩‘]

 

     #删除奇数位

     1）方法一 切片删除

     del l1[1::2]

     print(l1)

     [‘alex‘, ‘taibai‘, ‘老男孩‘]

 

     2）方法二 生成l2

     for i in range(len(11)):

          if i % 2 ==1:

               

     3）方法三 反向删

     for i in range(len(l1)-1,-1,-1):

          if i % 2 ==1:

               del l1[i]

     print(l1)

 

     在循环一个列表时，不要对列表进行删除的动作（改变列表元素的个数）

     

     引伸：range 可定制的数字列表，与for循环配合使用

          for i in range(10)

          print(i)

 

          for i in range(1,10)

 

          for i in range(1,10,2)

 

          for i in range(10,1,-1)

 

          print(range(10)) 可迭代对象，数字列表

     

     #字典相关 在循环字典时，不要改变字典的大小

     dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘,‘k3‘:‘v3‘,‘r‘:666}

     键值含有k的

     l1 = {}

     for i in dic:

          l1.append(i)

     for i in l1:

          del dic[i]

     print (dic)

     

     #tu相关 如果元组里面只有一个元素并且没有逗号隔开，那么它的数据类型与该元素一致

     tu1 = (1)

     print(tu1,type(tu1))

     tu2 = (‘alex‘)

     print(tu2,type(tu2))

     tu3 = ([‘alex‘,1,2])

     print(tu3,type(tu3))

 

 

11 小数据池，copy

     小数据池只涉及int和str

     id == is

     a = ‘alex‘

     b = ‘alex‘

     print(a == b) #数值

     print(a is b) #内存地址

     print(id(a))

 

     python中有小数据池概念

     int: -5~256的相同的数圈都指向一个内存地址

     str: s = ‘a‘ * 20 以内都是同一个内存地址

           只要字符串含有非字母元素，那就不是一个内存地址

 

 

     #深浅copy

     #赋值运算，它们共用一个列表

     a = [1,2,3]

     b = a

     a.append(666)

     print(a,b)

     

     

 

 

 

     #浅copy

     # 对于浅copy来说，第一层创建的是新的内存地址，而从第二层开始，指向的都是同一个内存地址，所以，对于第二层以及更深的层数来说，保持一致性。

     l1 = [1,2,3]

     l2 = l1.copy()

     l1.append(666)

     print(l1,l2)

     print(id(l1),id(l2))

 

 

     l1 = [1,2,3,[22,33]]

     l2 = l1.copy()

     l1.append(666)

     print(l1,l2)

     print(id(l1[-1]),id(l2[-1]))

 

　

 

     #深copy

      import copy

      

     l1 = [1,2,3,[22,33]]

     l2 = copy.deepcopy(l1)

     l1.append(666)

     print(l1,l2)

     print(id(l1[-1]),id(l2[-1]))