Python基础-day02

Posted 2020-09-18

写在前面

---

---

上课第二天，打卡：

　　　　大人不华，君子务实。

---

---

 

一、进制相关

- 进制基础

　　数据存储在磁盘上或者内存中，都是以0、1形式存在的；即是以 二进制 的形式存在；

　　为了存储和展示，人们陆续扩展了数据的表示形式：八进制 -> 十进制 -> 十六进制...

 二进制：0 1 10 11 100 101 110 111 1000 1001 1010 1011 1100 1101 1110 1111 10000 10001  ...
 八进制：0 1 2  3  4   5   6   7   10   11   12   13   14   15   16   17   20    21     ...
 十进制：0 1 2  3  4   5   6   7   8    9    10   11   12   13   14   15   16    17     ...
十六进制：0 1 2  3  4   5   6   7   8    9    a    b    c    d    e    f    10    11     ...

 - 文件读写相关函数方法

　　虽然硬盘上存储形式都是简单的0和1，但是随着计算机科学的快速普及和发展，兼容了越来越多的语言和文字；所以出现了很多编码形式；

　　然而每一种编码都有自己的对应关系且每个byte由8个bit组成：ASCII码规定每个字符由8个bit表示，不能表示汉字；utf-8规定每个汉字由24个bit表示；

　　更多参见：Python基础-day01

　　所以针对存储在硬盘上的数据，要想正确的识别并展示出来，就必须要知道其存储的编码格式，否则则会出现乱码；

#1 Python中文件读写的小例子：

1 #!/usr/bin/python
 2 # -*- coding:utf-8 -*-
 3 
 4 f1 = open(‘log‘,‘r‘,encoding=‘utf-8‘)
 5 f2 = open(‘log‘,‘rb‘)
 6 data1 = f1.read()
 7 data2= f2.read()
 8 print(data1)
 9 print(data2)
10 
11 result:
12 D:\\soft\\work\\python35\\python.exe D:/soft/work/Python_17/day02/s01.py
13 adada英文——_.
14 b‘adada\\xe8\\x8b\\xb1\\xe6\\x96\\x87\\xe2\\x80\\x94\\xe2\\x80\\x94_.‘
15 
16 Process finished with exit code 0


log文件内容：adada英文——_.

 

二、类和对象初探

- 类/class

类，具有某些属性和行为的抽象结构；

代码中，属性对应了一些变量，行为则对应了一些具体的方法；

- 对象/object

对象，是类的实例，即具有某些属性和行为的实物；

- 面向对象

　　- 封装

　　- 继承

　　- 多态

　　　　- 重载

　　...

> 例如：水果是一个类/class，香蕉则是一个对象/object；

- Python 中的类和对象

比如我们常用的字符串类型：

1 class str(object):{...}
2 ---
3 #!/usr/bin/python
4 # -*- coding:utf-8 -*-
5 
6 string = "Hello"
7 new_str = string.upper()
8 print(new_str)

 string 变量通过 ‘=‘ 赋值，成为了一个str类的对象实例，存储在内存中；因为str类具有 ‘upper()‘ 方法，所以string对象继承了该方法，可以执行相关操作；

三、基本数据类型常用方法介绍

- 字符串/str

　　- 类型：　　不可变（immutable）

　　下面这个小例子，试图修改字符串，解释器报错；

 1 #!/usr/bin/python
 2 # -*- coding:utf-8 -*-
 3 
 4 string = "Hello"
 5 print(string)
 6 print(string[2])
 7 string[2] = ‘+‘
 8 print(string)
 9 print(string[2])
10 
11 ---
12 D:\\soft\\work\\python35\\python.exe D:/soft/work/Python_17/day02/s03.py
13 Hello
14 l
15 Traceback (most recent call last):
16   File "D:/soft/work/Python_17/day02/s03.py", line 9, in <module>
17     string[2] = ‘+‘
18 TypeError: ‘str‘ object does not support item assignment
19 
20 Process finished with exit code 1

 　　- 基础功能

　　　　- 1.capitalize | 首字母大写

1 name = ‘alex‘
2 v = name.capitalize()
3 print(name)
4 print(v)
5 
6 ---
7 alex
8 Alex

 　　　　- 2.casefold 和 lower | 所有大写变小写，casefold 功能强于 lower

 1 name = ‘HeLLo!‘
 2 v = name.casefold()
 3 v2 = name.lower()
 4 print(name)
 5 print(v)
 6 print(v2)
 7 
 8 ---
 9 HeLLo!
10 hello!
11 hello!

 1 # ß 是德语里的一个大写字符
 2 
 3 name = ‘ß‘
 4 v = name.casefold()
 5 v2 = name.lower()
 6 print(v)
 7 print(v2)
 8 
 9 ---
10 ss
11 ß

　　　　- 3.center, ljust, rjust | 文本居中，居左，居右，并填充显示，arg1 -> 表示总长度；arg2 -> 表示填充字符；

 1 name = ‘standby‘
 2 v = name.center(10,‘#‘)
 3 v2 = name.ljust(10,‘@‘)
 4 v3 = name.rjust(10,‘+‘)
 5 print(v)
 6 print(v2)
 7 print(v3)
 8 
 9 ---
10 #standby##
11 [email protected]@@
12 +++standby

 　　　　- 4.count | 子序列在字符串中出现的次数；arg1 -> 子序列； arg2 -> 匹配查找的起始位置； arg3 -> 匹配查找的结束位置；

 1 desc = "This is www.iqiyi.com."
 2 v = desc.count(‘i‘)
 3 v2 = desc.count(‘is‘)
 4 v3 = desc.count(‘is‘,1,5)
 5 print(v)
 6 print(v2)
 7 print(v3)
 8 
 9 ---
10 5
11 2
12 1

 　　　　- 5.encode | 把字符串转换成 bytes 类型表示； arg1 -> 指定编码；

1 name = ‘中国‘
2 new_name1 = name.encode(‘utf-8‘)
3 new_name2 = name.encode(‘gbk‘)
4 print(new_name1, type(new_name1), len(new_name1))
5 print(new_name2, type(new_name2), len(new_name2))
6 
7 ---
8 b‘\\xe4\\xb8\\xad\\xe5\\x9b\\xbd‘ <class ‘bytes‘> 6
9 b‘\\xd6\\xd0\\xb9\\xfa‘ <class ‘bytes‘> 4

 　　　　- 6.endswith 和 startswith | 是否以xxx结尾、开头； arg1 -> xxx；arg2 -> 匹配查找的起始位置； arg3 -> 匹配查找的结束位置；

1 hitwh = "Just stick to what you love and believe in."
2 v = hitwh.startswith(‘Just‘)
3 v2 = hitwh.startswith(‘s‘,5,11)
4 v3 = hitwh.endswith(‘t‘,5,12)
5 print(v,v2,v3)
6 
7 ---
8 True True True

 　　　　- 7.expandtabs | 找到制表符\\t，进行替换；arg1 -> 指定替换后的长度（包含 ‘\\t‘ 前面的子序列）；

 1 my = ‘haha\\tPython_17\\twww.baidu.com\\nwww.standby.pub\\txxxx\\tlike‘
 2 print(my)
 3 v = my.expandtabs(20)
 4 print(v)
 5 
 6 ---
 7 haha    Python_17    www.baidu.com
 8 www.standby.pub    xxxx    like
 9 haha                Python_17           www.baidu.com
10 www.standby.pub     xxxx                like

 　　　　- 8.find 和 index | 查找子序列索引位置，不存在则返回 ‘-1‘；index查找，不存在的话就报错了；默认是从左向右查找，另外还有 rfind 和 rindex，即从右向左查找；

name = ‘alex‘
v = name.find(‘e‘)
v2 = name.find(‘o‘)
print(v)
print(v2)

---
2
-1

1 name = ‘alex‘
2 v = name.index(‘o‘)
3 print(v)
4 
5 ---
6 Traceback (most recent call last):
7   File "D:/soft/work/Python_17/day02/s02.py", line 35, in <module>
8     v = name.index(‘o‘)
9 ValueError: substring not found

　　　　- 9.format 和 format_map | 格式化输出的几种形式

 1 # Format output 1
 2 my = "I am %s, age is %s, gender is %s."
 3 print(my % (‘standby‘,22,‘male‘))
 4 # Format output 2
 5 my = "I am {0}, age is {1}, gender is {2}."
 6 print(my.format(‘standby‘,23,‘male‘))
 7 # Format output 3
 8 my = "I am {name}, age is {age}, gender is {gender}."
 9 print(my.format(name = ‘standby‘,age = 24,gender = ‘male‘))
10 # Format output 4
11 my = "I am {name}, age is {age}, gender is {gender}."
12 print(my.format_map({‘name‘:‘standby‘,‘age‘:25,‘gender‘:‘male‘}))
13 
14 ---
15 I am standby, age is 22, gender is male.
16 I am standby, age is 23, gender is male.
17 I am standby, age is 24, gender is male.
18 I am standby, age is 25, gender is male.

 　　　　- 10.isdecimal, isdigit, isnumeric | 判断是否是数字；isdecimal < isdigit < isnumeric

 1 num = ‘123‘
 2 num2 = ‘九十八‘
 3 num3 = ‘⑨‘
 4 v1 = num.isdecimal()
 5 v2 = num.isdigit()
 6 v3 = num.isnumeric()
 7 print(v1,v2,v3)
 8 v1 = num2.isdecimal()
 9 v2 = num2.isdigit()
10 v3 = num2.isnumeric()
11 print(v1,v2,v3)
12 v1 = num3.isdecimal()
13 v2 = num3.isdigit()
14 v3 = num3.isnumeric()
15 print(v1,v2,v3)
16 
17 ---
18 True True True
19 False False True
20 False True True

 　　　　- 11.isalpha | 判断字符串是否只有字母组成

 1 string = ‘str‘
 2 name = ‘alex123‘
 3 v = name.isalpha()
 4 v2 = string.isalpha()
 5 print(v)
 6 print(v2)
 7 
 8 ---
 9 False
10 True

 　　　　- 12.isalnum | 判断字符串是否由字母和数字组成

 1 name = ‘alex123‘
 2 string = ‘str赢.‘
 3 v = name.isalnum()
 4 v2 = string.isalnum()
 5 print(v)
 6 print(v2)
 7 
 8 ---
 9 True
10 False

　　　　- 13.isidentifier | 判断是否可以用作标识符、变量名

 1 string1 = ‘1a‘
 2 string2 = ‘int‘
 3 string3 = ‘name‘
 4 v = string1.isidentifier()
 5 v2 = string2.isidentifier()
 6 v3 = string3.isidentifier()
 7 print(v)
 8 print(v2)
 9 print(v3)
10 
11 ---
12 False
13 True
14 True

 　　　　- 14.islower 和 isupper | 判断字符串是否全都是大、小写

 1 name = ‘aLeX‘
 2 v = name.islower()
 3 v2 = name.isupper()
 4 print(v)
 5 print(v2)
 6 print(name.upper())
 7 print(name.lower())
 8 
 9 ---
10 False
11 False
12 ALEX
13 alex

 　　　　- 15.isprintable | 是否包含隐含的 ‘\\t‘ ‘\\n‘ ‘\\a‘...

 1 desc = ‘aaa121212---.‘
 2 name = ‘alex \\tsss‘
 3 v = name.isprintable()
 4 v2 = desc.isprintable()
 5 print(v)
 6 print(v2)
 7 
 8 ---
 9 False
10 True

 　　　　- 16.isspace | 是否全部是空格

 1 name = ‘    ‘
 2 name2 = ‘    .‘
 3 v = name.isspace()
 4 v2 = name2.isspace()
 5 print(v)
 6 print(v2)
 7 
 8 ---
 9 True
10 False

 　　　　- 17.join | 字符串/子序列拼接

 1 str = ‘alexall‘
 2 list = [‘A‘,‘L‘,‘E‘,‘X‘]
 3 v = ‘-‘.join(str)
 4 v2 = ‘‘.join(list)
 5 v3 = ‘<-->‘.join(list)
 6 print(v)
 7 print(type(v2),v2)
 8 print(type(v3),v3)
 9 
10 ---
11 a-l-e-x-a-l-l
12 <class ‘str‘> ALEX
13 <class ‘str‘> A<-->L<-->E<-->X

 　　　　- 18.lower, upper, swapcase | 大小写转换：全部变小写、全部变大写、大小写全部对换 

 1 name = ‘AleX‘
 2 v = name.lower()
 3 v2 = name.upper()
 4 v3 = name.swapcase()
 5 print(v)
 6 print(v2)
 7 print(v3)
 8 
 9 ---
10 alex
11 ALEX
12 aLEx

 　　　　- 19.strip, rstrip, lstrip | 移除空白，‘\\n‘，‘\\t‘，也可以自定义要移除的字符

 1 name2 = ‘   standby     ‘
 2 v2 = name2.strip()
 3 v3 = name2.lstrip()
 4 v4 = name2.rstrip()
 5 print(v2)
 6 print(v3)
 7 print(v4)
 8 
 9 ---
10 standby
11 standby     
12    standby

1 name = ‘alex‘
2 v = name.strip("x")
3 v2 = name.strip("a")
4 print(v)
5 print(v2)
6 
7 ---
8 ale
9 lex

　　　　- 20.maketrans 和 translate | 对应关系 + 翻译

1 m = str.maketrans(‘hello‘,‘12345‘) # 对应关系
2 name = "---->[email protected]<-----"
3 v = name.translate(m)
4 print(v)
5 
6 ---
7 ---->[email protected]<-----

　　　　- 21.partition，rpartition | 分割字符串，并保留自定义的分隔符；arg1 -> 分隔符；则返回一个3元的元组，第一个为分隔符左边的子串，第二个为分隔符本身，第三个为分隔符右边的子串。

1 name = ‘standby‘
2 v = name.partition(‘nd‘)
3 print(type(v),v)
4 v1 = name.split(‘nd‘)
5 print(type(v1),v1)
6 
7 ---
8 <class ‘tuple‘> (‘sta‘, ‘nd‘, ‘by‘)           <-- 元组，并且保留了自定义的分隔符： nd
9 <class ‘list‘> [‘sta‘, ‘by‘]                  <-- 列表，去掉了自定义的分隔符

1 name = ‘standby--nd++‘
2 v = name.partition(‘nd‘)
3 v2 = name.rpartition(‘nd‘)
4 print(type(v),v)
5 print(type(v2),v2)
6 
7 ---
8 <class ‘tuple‘> (‘sta‘, ‘nd‘, ‘by--nd++‘)
9 <class ‘tuple‘> (‘standby--‘, ‘nd‘, ‘++‘)

　　　　- 22.replace | 替换； arg1 -> 匹配的子序列； arg2 -> 指定替换后的子序列； arg3 -> 替换的个数

 1 content = "巴基斯坦help中国help俄罗斯help中国"
 2 print(content)
 3 v = content.replace(‘help‘,‘Love‘)
 4 print(v)
 5 v = content.replace(‘help‘,‘Love‘,2)
 6 print(v)
 7 
 8 ---
 9 巴基斯坦help中国help俄罗斯help中国
10 巴基斯坦Love中国Love俄罗斯Love中国
11 巴基斯坦Love中国Love俄罗斯help中国

　　　　- 23.split, rsplit | 通过指定分隔符 arg1 对字符串进行切片，如果参数 arg2 有指定值，则仅分隔 arg2 个子序列

 1 name = ‘standby--nd++And######[email protected]@@.‘
 2 v = name.split(‘nd‘)
 3 v2 = name.rsplit(‘nd‘)
 4 v3 = name.split(‘nd‘,2)
 5 v4 = name.rsplit(‘nd‘,2)
 6 print(type(v),v)
 7 print(type(v2),v2)
 8 print(type(v3),v3)
 9 print(type(v4),v4)
10 
11 ---
12 <class ‘list‘> [‘sta‘, ‘by--‘, ‘++A‘, ‘######world‘, ‘@@@.‘]
13 <class ‘list‘> [‘sta‘, ‘by--‘, ‘++A‘, ‘######world‘, ‘@@@.‘]
14 <class ‘list‘> [‘sta‘, ‘by--‘, ‘++And######[email protected]@@.‘]
15 <class ‘list‘> [‘standby--nd++A‘, ‘######world‘, ‘@@@.‘]

　　　　- 24. zfill | 填充0； arg1 -> 指定总长度，包括已有字符串长度；

1 name = "alex"
2 v = name.zfill(10)
3 print(v)
4 
5 ---
6 000000alex

 　　- 扩展补充

　　　　- 切片

 1 desc = ‘Hello @[email protected] world.‘
 2 print(desc)
 3 print(desc[0])
 4 print(desc[3:7])
 5 print(desc[0:8:2])
 6 
 7 ---
 8 Hello @[email protected] world.
 9 H
10 lo @
11 [email protected]

 　　　　- 求长度和 for循环遍历

1 desc = ‘Hello @[email protected] world.‘
2 print(len(desc))
3 for i in desc:
4     print(i)
5 for i in range(0, len(desc)):
6     print(desc[i])

 

- 整数/int

　　- 类型　　不可变（immutable）

 1 >>> num=1
 2 >>> id(num)         <-- 查看num的内存地址
 3 1795490256
 4 >>> num2=1　　　　　　<-- 给num2赋予同样的值：1
 5 >>> id(num2)        <-- num2 和 num 引用的是同一个内存地址，可见 Python3 在内存中为每一个值只保存一份；
 6 1795490256
 7 >>>
 8 >>> num=9            <-- 给num重新赋值：9
 9 >>> id(num)          <-- num 的内存地址已经更改了，所以int值是不可变类型的！
10 1795490512
11 >>> id(num2)
12 1795490256
13 >>>
14 >>> num
15 9
16 >>> num2
17 1
18 >>>

 

　　- 基础功能

　　　　- 1.bit_length | 查看某整数用二进制表示时的最小位数； 可以用 ‘bin()‘ 函数获得整数的二进制表示形式；

 1 print("十进制".ljust(5),"二进制".ljust(5), "二进制表示的最小位数")
 2 for i in range(1,9):
 3     print(str(i).ljust(10), bin(i).ljust(10), i.bit_length())
 4 
 5 ---
 6 十进制   二进制   二进制表示的最小位数
 7 1          0b1        1
 8 2          0b10       2
 9 3          0b11       2
10 4          0b100      3
11 5          0b101      3
12 6          0b110      3
13 7          0b111      3
14 8          0b1000     4

 

 

　　　　- 2.to_bytes | 获取指定整数的字节按照大小端序进行表示

 1 num_list = [254,255,256,257]
 2 for age in num_list:
 3     print("%s  大端序  -->  %s" % (age, age.to_bytes(4,‘big‘)))
 4     print("%s  小端序  -->  %s" % (age, age.to_bytes(4,‘little‘)))
 5 
 6 ---
 7 254  大端序  -->  b‘\\x00\\x00\\x00\\xfe‘
 8 254  小端序  -->  b‘\\xfe\\x00\\x00\\x00‘
 9 255  大端序  -->  b‘\\x00\\x00\\x00\\xff‘
10 255  小端序  -->  b‘\\xff\\x00\\x00\\x00‘
11 256  大端序  -->  b‘\\x00\\x00\\x01\\x00‘
12 256  小端序  -->  b‘\\x00\\x01\\x00\\x00‘
13 257  大端序  -->  b‘\\x00\\x00\\x01\\x01‘
14 257  小端序  -->  b‘\\x01\\x01\\x00\\x00‘

 

　　　　- 3.from_bytes | 把指定大小端序的bytes对象转换成十进制整数表示

1 num_byte_list = [b‘\\x00\\x00\\x00\\xfe‘, b‘\\x00\\x00\\x00\\xff‘, b‘\\x00\\x00\\x01\\x00‘, b‘\\x00\\x00\\x01\\x01‘]
2 for by in num_byte_list:
3     print("%s  大端序转换为十进制数  -->  %d" % (by, int.from_bytes(by, ‘big‘)))
4 
5 ---
6 b‘\\x00\\x00\\x00\\xfe‘  大端序转换为十进制数  -->  254
7 b‘\\x00\\x00\\x00\\xff‘  大端序转换为十进制数  -->  255
8 b‘\\x00\\x00\\x01\\x00‘  大端序转换为十进制数  -->  256
9 b‘\\x00\\x00\\x01\\x01‘  大端序转换为十进制数  -->  257

- 布尔值/bool

　　- 类型　　不可变（immutable）

　　- 基础功能

　　　　- 整数里只有0是 False，其他都是 True

　　　　- 字符串里只有 "" 是 False，其他均是 True

　　　　- 如果列表为空，即[] 视为 False，其他均是 True

　　- 扩展补充

　　　　- 经常会把 ‘while True‘ 这样用作最外层的循环使用；

- 列表/list

　　- 类型

　　-基础功能

　　- 扩展补充

- 元组/tuple

　　- 类型

　　- 基础功能

　　- 扩展补充

- 字典/dict

　　- 类型

　　- 基础功能

　　- 扩展补充

- 集合

　　- 类型

　　- 基础功能

　　- 扩展补充

四、关于循环的补充

- while

a

- for

aaa

- range 和 xrange

aaa

- enumerate

 

五、练习题

a

六、day02课后作业

 1 """
 2 # 1. 练习题两个试卷：readme
 3 # 2. 购物系统
 4     - 个人账户,文件： user,pwd,3,余额
 5     - 商品，文件
 6     - 查看商品分页显示：
 7         li = [
 8             {...}
 9             {...}
10             {...}
11             {...}
12             {...}
13             {...}
14             {...}
15         ]
16         p = int(input(‘请输入页码：‘))
17         start = (p -1) * 10
18         end = p * 10
19         v1 = li[start:end]
20         for i v1:
21             print(i)
22     - 个人购物记录，文件
23         查看：娃娃
24     if "al" in "alex":
25         pass
26 """