（萌新笔记）python的复习笔记

简介：python，作为我在暑假入门的第一门语言，我发现它特别简洁和实用，因此我想记录我的python学习过程，现在刚刚大一入门（我比较弱鸡，所以本文可能会有记录很多我初学时遇到的问题，还请大家斟酌观看

Start！─=≡Σ((( つ•̀ω•́)つ

一、小知识点

1.IDLE是python的交互模式
2.python里面的双引号（" “）和单引号（’ ‘）基本没有区别（至少目前看来，现在正在学函数）
3.python的IDLE，按ctrl+N可直接打开其编辑器
4.在IDLE中回车键表示运行，换下一行要按ctrl+J
5.BIF即内置函数
6.python的布尔类型叫bool，C语言的叫_Bool；pyhton的布尔类型只有True和False，C语言的布尔类型只有0和!0
8.python不同句子若要出现在同一行，必须在句子间加分号
9.python具有严格的格式性，譬如你新起一行，在打印print的前面加个空格，程序都不给运行
10.当print( )里面接收的是字符串的时候，输出时会自动去掉其引号（’ ‘）
11. 2**3即2的三次方，结果为8；5e+3即5乘十的正三次方（5000）
12. python支持中文字符（串），后面会有讲到
13. python看作假的：False、None、0、’’、”"、（）、[]、{} （注意：符号里面无字符）
14. dir（）用来查询一个参数的所有属性、方法列表
15. help（）用来查看、了解模型、类型、对象、方法的详细信息
16.可用assert判断语句的对错，若assert后面接的语句是正确的则忽略，否则程序直接停止，用法如下：

assert 1-1==0	#忽略，程序照常进行
assert 1-1==1	#报错，程序停止

17.使用print函数时可以输入多个语句，只需要中间加个逗号，如：

print("123",4)

output：123 4

二、转义字符（只能用在字符串）

类似于:

\'   \"   \n   \t   \\

上面这些常用的我就不讲了，我就讲一下某些比较特殊的吧

1.\a
这个响铃不是指从声卡上放出来的，连接在声卡上的音箱和耳机响，而是指主板上的蜂鸣器，刚刚开机的时候，进Windows前“嘀”的一声就是用来发那个声音的，但现在很多机器没有蜂鸣器了。如果你开机的时候静悄悄，那就可能是属于“现代的计算机”，没有蜂鸣器了

2.\b
就是退格符，如输入：“1\b”，就相当于什么都没输入，那这个有什么用呢？其实这个常用于循环，如在第一个循环你想要个框（"|"）你可以在循环中不添加"\b"，第二个循环你不想要框你就可以在"|“后面添加个”\b_"（_是空格）就变成了" "，就没有框了

3.\v \f
这两个我也没怎么接触，作用分别是纵向制表符、换页符，按照我个人猜想这俩应该在制作文档时或是打印机打印内容时使用的

4.\r
回车符，一般可以用在循环中，比如中间插个if(…)：putchar(’\r’)，代表满足某个条件时程序自动按回车（这时就会触发提前设置好的某个条件），是得程序按照想要的流程进行

5.markdown 打印不出来（直接上代码）

a = '\x0a'
#\x..格式表示x加两位数字，意思是用两个16进制的数来表示一个字符
b = '\147'
#\...格式表示三位数字，意思是用三个8进制数表示一个字符
print(a,b)

output:  #这个字符是空格
	   g #这个字符是字母g

6.\000
这是空格，也举个例子吧

print("123\000456")
print("123\0000456")

output:123 456
	   123 0456

以上就是全部转义字符了，最后补充一点当编程中有很多 \ 但并不想表示转义的时候只需要在前面加个 r 就可以了

print（r'\n\147\t\000\x0a'）

output:\n\147\t\000\x0a #加了个r后就全部打印出来了

三、格式化

在此之前，我们先讲一下format( )函数的四种常用用法：
One 隐性用法
先补充一点：input( )函数接收一个标准输入数据，强制返回str类型（即输入什么都会被当成字符串来输出）

temp1 = input("name:")
temp2 = input("age:")
temp3 = input("tall:")
print(f"name is {temp1},age is {temp2},tall is {temp3}")

input:name:1
	  age:2
	  tall:3
output: name is 1,age is 2,tall is 3

这是format的隐性用法，print括号前面加的 f 应该就是format的意思

Two 位置参数

input："{0} am {1} {2}".format("I","Iron","man")
output：'I am Iron man'

你甚至可以将1和2互换位置，那么打印时就变成了’I am man Iron’，同理0也可以和1或2互换位置

Three 关键字参数

input："{a} am {b} {c}".format(a = "I",b = "Iron",c = "man")
output：'I am Iron man'

这个就比位置参数更通俗易懂了，比如将 b 和 c 互换位置，那么打印时就变成了’I am man Iron’，同理各个位置参数都是可以互换的

Four 转义

input："{{0}}".format("不打印")
output：{0}

这个双重大括号相当于//一样是转义的意思，即转义大括号位置参数的用法，使其变成普通字符

现在开始讲我们的重点：格式化操作符%

格式化操作符	作用
%d	格式化整数
%s	格式化字符串
%f	格式化小数，可指定小数点后的精度
%c	格式化字符
%e	用科学计数法格式化浮点数
%E	同上
%g	自动选择合适的格式方式
%G	同上
%o	格式化无符号八进制
%u	格式化无符号十进制
%x	格式化无符号十六进制
%X	同上

举例 ing

input: '%c%c%c%c' % (17,105,115,104)
output: 'Fish'

input: '%d转八进制是:%o' % (123,123)
output: '123转八进制是:173'

input: "%s" % "希望世界和平"
output: "希望世界和平"

格式化操作符的辅助命令

符号	含义
m.n	m显示的是最小宽度，n是小数点后的位数
-	结果左对齐
+	在正数显示＋号
#	在八进制前面显示’0o’，在十六进制前面显示’0x’或’0X’
0	显示的数字前面填充’0’代替空格

举例 ing

input: '%5.17f' %  24.658
output: '27.7'

input: '%.2e' %  27.658
output: '2.77e+01'

input: '%-10d' %  5
output: '5         '

input: '%010d' %  5
output: '0000000005'

input: '%#o' %  10
output: '0o12'

补充一种ASCII码的打印方法( 要用到ord( )函数 )：

c = input("请输入一个字符: ")
print( c + " 的ASCII 码为", ord(c))

input: 请输入一个字符: a
output: a 的ASCII 码为 97

再补充另一种格式化写法：

input："{:.2f}".format(37)
output：37.00

input: '{:#o}'.format(10)
output: '0o12'

解析第一个： 引号（:）相当于%号，代表格式化开始；点（.2）表示小数点后两位；f 表示浮点数

四、python的运算符

在python中，有7种运算符：算术运算符、比较(关系)运算符、赋值运算符、逻辑运算符、位运算符、成员运算符、身份运算符 ~~~ 老规矩，讲讲不常用的

1、算术运算符

包含：

 +  -  *  /  %  **  //

//（floor地板除）的用法（相当于C语言的 / 的用法）：

5//3 = 1  -5//3 = -2

即除法运算结果，若算出小数则砍掉小数部分（非四舍五入），有符号则算完后最后加符号

%（求余）和 / （除号）和 **（次幂）的用法：

5 % 3 = 1   4 % 2 = 0   4/2 = 0   5/2 = 2.5  2**3 = 8

即字面意思，求余数 和 除法运算 和 次幂运算符(次幂的运算顺序为从右至左)

2、逻辑运算符

包含：

not   and   or

当 not 和 and 及 or 在一起运算时，优先级为是not > and > or，教你怎么记（闹太套）ε=ε=ε=ε=ε=ε=┌(;￣◇￣)┘（逃

3、比较运算符

包含：

<   >   ==   !=   <=   >=

三元操作符（比较两个值的最小值举例）：

small = x if x < y else y

四元操作符（比较三个值的最小值举例）：

small = x if (x < y and x < z)else(y if y < z else z)

补充：python支持直接互换变量:

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

output:3,1,2

4、赋值运算符

就是= 、 += 、 //= 、 **= 之类的

5、身份运算符

即 is 和 is not
x is y, 类似 x == y
x is not y ， 类似 a = b

<提示：is 和 not 的顺序别写反>

6、成员运算符

即 in 和 not in
x in y, 类似 ‘雨’ in “大雨”
x is not y ， 类似 ‘雨’ not in “大雨”

<提示：in 和 not 的顺序别写反>

7、位运算符

这个就涉及到二进制了（不要求掌握）

运算符	描述
&	按位与运算符： 参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
|	按位或运算符： 只要对应的二个二进位有一个为1时，结果位就为1。
^	按位异或运算符： 当两对应的二进位相异时，结果为1
~	按位取反运算符： 对数据的每个二进制位取反,即把1变为0,把0变为1 ；~x 类似于 -x-1
<<	左移动运算符： 运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。
>>	右移动运算符： 把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数

下面代码中变量 a 为 60，b 为 13，二进制格式如下：

a = 0011 1100

b = 0000 1101

-----------------

a & b = 0000 1100

a | b = 0011 1101

a ^ b = 0011 0001

~a  = 1100 0011

(a & b) 输出结果 12 ，二进制解释： 0000 1100
(a | b) 输出结果 61 ，二进制解释： 0011 1101
(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
(~a ) 输出结果 -61 ，二进制解释： 1100 0011
a << 2 输出结果 240 ，二进制解释： 1111 0000
a >> 2 输出结果 15 ，二进制解释： 0000 1111

注意：

对于 & 和 |
&就相当于且，| 就相当于或，高中背过的：且，有假则假，或，有真则真

对于 左、右移动操作
左移操作，a< 右移操作，a>>b的结果为，将a的各个位向右移动b位，右侧b位抛弃，左侧补b个0或1；当a为无符号数，或正数时，左侧补0；当a为有符号负数时，左侧补1（这个涉及到二进制储存十进制的原理）

对于按位异或运算符

  a:0011 1100
  b:0000 1101
a^b:0011 0001 #相同就0不同就1

我知道上面涉及到的位运算符比较难，所以看不懂的也不要紧，下面又回到正常难度了 (ฅ´ω`ฅ)

五、python的基本类型

包含：int、float(double)、str、bool、列表、元组、字典、集合
PS：前四个统称数据类型

当我们需要判断一个变量的数据类型时，我们有两种方法：
1.type（）函数

input:type(520)
output:<class 'int'>

input:type('520')
output:<class 'str'>

2.isinstance（）函数

input:a = '520'
	  isinstance(a,str)
output:True

input:isinstance(a,int)
output:False

input:isinstance(520,int)
output:True

现在正式开始基本类型的举例！

int 和 float(double)、bool这些我们熟知的就不讲了吧~
<提及一下，前四个是可以相互转换的>

1、列表

python的列表相当于C语言的数组，但是列表强大的地方在于它可以同时存放不同类型的变量
下面会举例说明python列表常用的几个方法：

>>>在此代码片的意思是input（输入）
本代码片是直接照仿python的IDLE来运行的
---------------------------------------------------

>>> a = ['钢铁侠','蜘蛛侠']

>>> a
['钢铁侠','蜘蛛侠']

>>> a.append('浩克') #加入一个元素（这个元素可以是普通字符也可以是一个排列）

>>> a
['钢铁侠','蜘蛛侠','浩克']

>>> a.extend(['奇异博士'])#加入一个排列（这个排列可以只含一个元素也可以含多个元素）

>>> a
['钢铁侠','蜘蛛侠','浩克','奇异博士']

>>> a.insert(0,'黑寡妇') #在排列指定的位置加入一个元素（这个元素可以是普通字符也可以是一个排列）
['黑寡妇','钢铁侠','蜘蛛侠','浩克','奇异博士']

>>> a[0]
'黑寡妇'

>>> a.remove('浩克') #删除列表中指定的元素（若排列中有重复元素，则删掉排最前面的一个元素）

>>> a
['黑寡妇','钢铁侠','蜘蛛侠','奇异博士']

>>> del a #删掉整个列表

>>> a
name 'a' is not defined #程序显示 a 列表未定义

>>> b = ['黑寡妇','钢铁侠','蜘蛛侠','浩克','奇异博士']

>>> del b[0] #删除列表中指定的元素

>>> b
['钢铁侠','蜘蛛侠','浩克','奇异博士']

>>> b.pop() #删掉列表中最后一位元素
'奇异博士' #会返回你删掉的值

>>> b
['钢铁侠','蜘蛛侠','浩克']

>>> which = b.pop() #删掉列表中最后一位元素，但将此元素赋值给 which
>>> which
'浩克' #会返回你删掉的值

>>> b
['钢铁侠','蜘蛛侠']

>>> b.pop(0) #删除列表中指定的元素
>>> '钢铁侠' #会返回你删掉的值

>>> b
['蜘蛛侠']

>>> b.clear() #清空列表中的元素但保留列表

>>>b
[]

下面讲讲分片法 和 索引方法：

>>>在此代码片的意思是input（输入）
本代码片是直接照仿python的IDLE来运行的
---------------------------------------------------
>>> list_1 = list(range(100)) #为其赋值 0，1，2...98，99

>>> list_1[:4] #分片法，前面省略为 0
[0,1,2,3]

>>> list_1[-10:] #分片法，前面为倒数第十位元素，后面为最后一位元素的位置加一
[90,91,92,93,94,95,96,97,98,99]

>>> list_1[-10:99] #分片法，前面为倒数第十位元素，后面为最后一位元素
[90,91,92,93,94,95,96,97,98]

>>> list_2 = [1,2,3,4,5,6,7,8,9] #为新的变量赋值

>>> list_2[0:9:2] #间隔为2的排序
[1,3,5,7,9]

>>> list_2[::-2] #间隔为-2的排序
[9,7,5,3,1]

>>> list_2 #上面的只是打印而已，真正的列表丝毫不受影响
[1,2,3,4,5,6,7,8,9]

>>> del list_2[::2] #del语句

>>> list_2 #受到 del语句的影响而改变
[2,4,6,8]

>>> list_3 = [1,1,2,3,5,8,13,21] #为新的变量赋值

>>> list_3.count(1) #统计某个元素在列表中出现的次数
2

>>> list_3.index(1) #查找某个元素第一次出现的位置
0

>>> list_3.index(5,1,6) #查找某个元素第一次出现的位置（并限定查找范围）
4

>>> list_3.reverse() #对列表进行倒叙

>>> list_3
[21,13,8,5,3,2,1,1]

>>> list_3.sort() #将列表从小到大进行排序

>>> list_3
[1,1,2,3,5,8,13,21]

>>> list_3.sort(reverse = Ture) #将列表从小到大进行排序并进行倒叙（即从大到小进行排列）

>>> list_3
[21,13,8,5,3,2,1,1]

最后说一下列表的一些特性：

>>>在此代码片的意思是input（输入）
本代码片是直接照仿python的IDLE来运行的
---------------------------------------------------
>>> tep_1 = [123，999]
>>> tep_2 = [234，111]

>>> tep_1 < tep_2 #比较的是第一个数字的值大小，而不是全部元素的数值总和
True

>>> tep_3 = ['abc']
>>> tep_4 = ['de']

>>> tep_3 < tep_4 #比较的是第一个字母，而不是字母数量
True

>>> tep_1 + tep_2 #加的是列表元素，而不是元素数值
[123,234]

除了第一个代码片所用的方法和 del 语句和 clear 语句外，没有赋值号（=）的方法都只是打印并不是真正的修改

补充：列表复制，我看了篇博客叫：python列表复制，我觉得他写的已经非常好以至于我想不出有什么可以补充的，所以大家可以去看看他的

2、元组

元组相对于列表最大的区别就是：只可以访问，不可以修改
元组的标志：逗号（，）

内容	类型
( 1 )	int
（ ）	tuple(元组)
（ 1，）	tuple(元组)
1，	tuple(元组)
（ ，1）	error（出错）
[ ]	list

补充个例子：

8 * 8 == 64 # int
8 *（8，） == （8，8，8，8，8，8，8，8） # tuple

虽然说元组是不可以修改的，但我们可以用另一种方式更新和删除元组：添加标签
添加标签的原理是：创建一个同名数组

>>>在此代码片的意思是input（输入）
本代码片是直接照仿python的IDLE来运行的
---------------------------------------------------
>>> tep = (0,1,3,4)

>>> tep
(0, 1, 3, 4)

>>> id(tep)
2223370921768 #这是tep的地址

>>> tep = tep[:2] + (2,) + tep[2:](0, 1, 3, 4) #添加一个新标签

>>> tep
(0, 1, 2, 3, 4)

>>> id(tep)
2223371256912 #这是新的tep的地址，对比明显不一样，说明换的不是元组内的元素

>>> tep[4:] #哪怕只有一个元素，元组都会打印逗号（标志性）
(4,)

>>> del tep #删除元组

>>> tep
name 'a' is not defined #程序显示 tep 元组未定义

3、str型

又称字符串型，在python中有涉及相当多的字符串的各种内置函数；

与元组类似，字符串一旦定义好了就不能修改了，但可以用添加标签的方法进行更新；

因为字符串的内置函数有太多了，所以我就不一一列举了，这个是小甲鱼写的字符串的方法及注释，你们可以看看（顺便为小甲鱼的良心视频打Call，你们可以去了解一下，因为我就是从小甲鱼的视频入门的 ε٩ (๑> 灬 <)۶з）

下面我将介绍几种可能不太好理解的函数：

1、join(iterable)

tep = 'ok'
tep.join('THE') #join只接受一个参数

output:'TokHokE'

将iterable里的对象插入到变量tep中
iterable意为可迭代的，包括列表、元组、字典等对象，故还存在类似于下面的操作

countries = ['中国','俄罗斯','美国']
'_'.join(countries)

output:'中国_俄罗斯_美国'

2、partition(sep)

tep = 'Youareok' #将sep前、sep、sep后分为三个元组
tep.partition('a')

output:('You','a','reok')

若字符串里不含sep,则

tep = 'Youareok'
tep.partition('w')

output:('Youareok', '', '') #后面两个元素为空（但是还是要打印出来）

3、split(sep = None,maxsplit = -1)

tep = 'I am a human'
tep.split(sep = ' ',maxsplit = 2) #maxsplit为可分割的最大次数，若未添加着默认为无限次

output:['I', 'am', 'a human']

4、translate(table)

tep = 'aaabbaaa'
tep.translate(str.maketrans('b','f'))

output:'aaaffaaa'

中间只能填 str.maketrans(‘A’,‘B’) ，用于将A替换成B（的确很麻烦，所以常用replace函数）

translate函数和replace函数的区别：
①replace函数可以自定义修改的次数，而translate函数不能
②translate函数改的实质是ASCII码的替换，若单独输入str.maketrans(‘b’,‘f’)则会打印出{98: 102}（显示的是它们的ASCII码）

3（2）、序列

列表、元组、字符串统称为 序列

补充概念：迭代
迭代是重复反馈过程的活动，目的通常是为了接近并到达所需的目标或结果，每一次对过程的重复被称为一次迭代，而每一次迭代得到的结果会被用来作为下一次迭代的初始值

min、max函数可以迭代 [ ] 、( )、 ’ ’
sum函数只可以迭代 [ ]、( )
sorted函数也可以迭代 [ ] 、( )、 ’ '，但只返回 [ ]

倒置函数、枚举、zip 三者都可迭代所有对象，但皆需要用list（reversed（））的格式才能返回正确的值

倒置函数 reversed

a = [1,5,6,8,11]
list(reversed(a))
sorted(list(reversed(a)))

output:[11, 8, 6, 5, 1]
	   [1, 5, 6, 8, 11]
使用方法和字符串的内置函数很像，但用此函数迭代字符串或是列表所打印出来的一定是列表


枚举 enumerate

a =(1，2，3)
b = "123"
list(enumerate(a))
list(enumerate(b))

output:[(0,1),(1,2),(2,3)]
   	   [(0,'1'),(1,'2'),(2,'3')]
返回的是列表，且元素是带括号的，括号内第一个是索引值（按0123排序），第二个是迭代元素


zip

a = (1,2,3) #3个元素
b = [1,2,3,4] #4个元素
c = "12345" #5个元素
list(zip(a,b,c))

output:[(1,1,'1'),(2,2,'2'),(3,3,'3')]
zip 支持多参数同时压缩，去最小元素为限度，返回列表，且元素是带括号的，括号内三个值分别是a、b、c的元素

六、循环

我觉得python的循环语句比较简单，没什么可讲的，而可能比较难的break和continue我在另一篇博客中有讲到 ? 最通俗易懂的方式讲解break和continue

预示：在python语言的复习笔记系列的第二篇会讲字典、集合和函数哦！
————————————————————————————————————————————

(•‾̑⌣‾̑•)✧˖°终于结束了~

这是（萌新笔记）python语言的复习笔记系列的第一篇，今后我也会多出些高质量的笔记，也希望大家多多关注我哟(＾Ｕ＾)ノ~ＹＯ

还有，其实我也是刚刚开始使用CSDN博客，所以可能没有那么熟练，在写的过程中可能也有些疏忽，若你们在阅读的过程中发现了什么问题，或者想补充些知识点，也请大家在评论区里面留言斧正,互相交流学习，我不胜感激~

最后再一次感谢大家ヾ(￣▽￣)Bye ~ Bye~