PYTHON学习笔记

PYTHON学习笔记

此笔记记录本人在学习python值得注意的地方，主要记录与C的不同之处，和遗忘的地方，仅为本人自学使用
人生苦短，我用Python

1 字符串

对于字符串，PYTHON相对于其他编程语言具有很大一部分的简化操作。

1.1 转义字符的屏蔽

”r“可以屏蔽转义字符

print(r"python\n")
输出：python\n

1.2 字符串的连接

用“*”来重复字符串，用“+”来连接字符串

3*'am'+'sb'
输出amamamsb

1.3 字符串的索引

python可以用“索引”的技巧，本人认为非常好用

word='python'
word[0]
输出：p
word[5]
输出：n

1.4 索引的切片操作

word='python'
word[0:2]
输出：py

这里有一个知识点，word[0] 输出’p’
word[2]输出’t’
为什么word[0:2]输出’py’呢
看下面这张图片你就懂了

1.5 内置函数len()

可以返回字符串的长度*/

2 几个陌生的运算符

2.1 **

幂运算符，a**b，返回a的b次幂

2.2 //

取整除：返回商的整数部分
如7//3
输出：2
直接删除结果的小数部分

2.3 位运算符

比较简单，之前学过，但用的比较少，不做赘述

2.4 逻辑运算符

这里的逻辑运算符与C的不同，需要格外注意
and 逻辑与
or 逻辑或
not 逻辑非
输出的时为布尔值，True，Flase

2.5 关键字in和is

in：用来判断是否包含指定序列

5 in (1,4,5,10,16)
输出：True
5 in (1,4,10,16)
输出：Flase

is:用于检验两个变量是否指向同一个对象的一个运算符
可以理解为检验两个指针是否指向同一个地址

3.流程控制

3.1 if的基本语法

if的使用方法与C基本相同，语法格式如下

if 表达式：
	语句1
	语句2
elif 表达式：
	语句3
	语句4
else：
	语句5

3.1.1表达式的用法

（1）if判断语句中的表达式为逻辑判断时，表达式的输出值为布尔值，当逻辑表达式为True时，执行。当为Flase时，不执行
（2）if判断语句中的表达式为数字时，只有数字为0时，才为Flase，其余都为True
（3） if判断语句的表达式为字符串时，只有字符串为空时，才为Flase，其他情况为True

3.1.2 if的一种与独有的用法

此用法将传统的语法结构变为逻辑表达式
实现方法:

条件成立时执行的语句 if condition else 条件不成立时执行的语句

个人评价：此类方法可以减少代码行数，但华而不实，整体上看的话代码不美观，并且与正常方法的实现效果相同

3.2 while循环

python中while与C的使用方法大同小异，只是语法结构略有不同

while condition:
	statement(s)

3.2.1 break 和continue

用法与C语言相同，不多说了
break每次只跳出一层循环体

3.2.2 循环语句中的else

非常有用的一种结构
此种结构可以在不使用标志位的情况下，来检测循环的退出情况
（1）当中途退出while时，不执行else的内容
当循环结束后退出while是，执行else的内容
代码举例

count=0
while count <5:
    print(count,"is less 5")
    if count ==3 :
        break
    count=count+1
else: 
	print(count,"is not less than 5")

3.3 for循环

语法结构语法结构为

for 变量 in 可迭代对象
	statement(5)

3.3.1 range()函数

range()是for循环的好哥们，经常在一起使用
使用方法
range(stop)
range(start,stop)
range(start,stop,step)

for i in range(0,10):
	print(i)

4 列表

列表是python中常见的序列

rhyme = [1,2,3,4,上山打老虎]

列表作为python的非常经典的数据存储结构，有很多的使函数

4.1 列表的增删

4.1.1 append

在列表的末尾追加一个元素

rhyme.append["老虎没打着"]

4.1.2 extend

用迭代的方法，在列表尾部增加多个元素

rhyme.extend["老虎没打着"，"打到个小松鼠","耶耶耶"]

4.1.3 insert

可以选择插入的位置，每次只能插入一个元素

rhyem.insert(插入的位置，插入元素)

4.1.4 pop

删除指定位置的元素，默认为零(即删除最后一个元素)

rhyme.pop()
rhyme.pop(2)

4.1.5 remove

删除查找到的第一个元素，无返回值，如过没有目标元素，就会报错

rhyme.remove("上山打老虎")

4.1.6 clear

清空列表

rhyme.clear()

4.2列表的拼接

4.2.1列表的加法

S =[1,2,3]
t =[4,5,6]
s+t
输出：[1,2,3,4,5,6]

4.2.2二维列表

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

4.2.3 列表的嵌套

嵌套列表的生成

A=[None]*3
for i in range(3):
	A[i]=[None]*2
输出：[[None, None], [None, None], [None, None]]

下面这张图片说明了一个问题

列表这不能这么生成，这么生成不是拷贝，只是重复的引用

4.3列表的拷贝

说到拷贝，这里必须与引用做一个区分

X=[1,2,3]
Y=X
X

此时X和Y指向同一个对象，其中一个改变都会改变，是引用的关系。

4.3.1 copy() (一种浅拷贝)

X=[1,2,3]
Y=X.copy()

此时会生成一个叫Y的新的列表
此种拷贝只能拷贝外层的对象，不能拷贝嵌套的结构

4.3.2 切片拷贝方法 (一种浅拷贝)

X=[1,2,3]
Y=X[:]

4.3.3 copy模块的使用方法

copy模块相当于一个库函数，使用前需要声明，此方法可以进行浅拷贝，也可以进行深拷贝
注：深拷贝会全方位360°无死角的拷贝所有的嵌套

浅拷贝语句: y=copy.copy(x)
深拷贝语句 y=copy.deepcopy(x)

4.4列表推导式

左边是表达式，右边是一个正常的for循环，得到的值存回之前的值中

基本语法：expression for target in iterable

列表表达式最擅长的是对整个列表做相同的操作，并且返回得到一个新的列表。

4.4.1 多维列表的列表推导式生成方法

s=[[0]*3 for i in range(3)]
s
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]

4.4.2 列表推导式与if的联合使用

一种列表推导式的跟高级的方法

基本语法：expression for target in iterable if condition

举例说明

even = [i for i in range(10) if i%2 == 0]
even
[0, 2, 4, 6, 8]

在这个式子中，先进行if判断，在进行前面表达式的计算

4.4.3 列表推导式的嵌套使用

其实就是一种嵌套的使用的另外一种表示方法，多练习即可

4.5 元组

元组与列表非常相似，大部分方法都通用，但是元组与列表的最大区别是列表可以、增删、改，但是元组不能添加、删除、修改元素，只能将整个元组删除。

4.5.1 元组的定义

以“()”的形式即可定义一个元组
指定义一个元素的元组时，元素后面需要加一个逗号，否则元素还是原来的类型

a1=(1,2,3)
只定义一个元素的元组：a2=(1,)

4.5.2 删除元组

元组不能修改，只能进行整个的删除

del a1

4.5.3 元组的其他操作

元组的其他操作和列表基本相同
如：count，计数功能
index，查找元组中元素的索引位置

5 字符串

方法	描述
string.capitalize()	把字符串的第一个字符大写
string.title()	返回"标题化"的 string,就是说所有单词都是以大写开始，其余字母均为小写
string.swapcase()	翻转 string 中的大小写
string.upper()	转换 string 中的小写字母为大写
string.lower()	转换 string 中所有大写字符为小写.
string.center(width)	返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
string.ljust(width)	返回一个原字符串左对齐,并使用空格填充至长度 width 的新字符串
string.rjust(width)	返回一个原字符串右对齐,并使用空格填充至长度 width 的新字符串
string.zfill(width)	返回长度为 width 的字符串，原字符串 string 右对齐，前面填充0
string.count(str, beg=0, end=len(string))	返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
string.index(str, beg=0, end=len(string))	跟find()方法一样，只不过如果str不在 string中会报一个异常.
string.find(str, beg=0, end=len(string))	检测 str 是否包含在 string 中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1

还有非常多的字符串操作函数，百度搜索即可，不多说了

6 序列

列表、元组、字符串均叫序列

6.1序列的常见函数

6.1.1 id()

id() 函数返回对象的唯一标识符，标识符是一个整数。

6.1.2 del

删除序列，或函数序列的部分元素

x=[1,2,3,4,5]
del x[1:3]
x
[1, 5]

6.2 列表、元组、字符串相互转换的函数

list()、tuple()、str()
list() 方法用于将元组转换为列表。
注：元组与列表是非常类似的，区别在于元组的元素值不能修改，元组是放在括号中，列表是放于方括号中。
tuple() 函数将列表转换为元组。
str():将元组和列表转化为字符串

6.3 max min

min() 方法返回给定参数的最小值，参数可以为序列。
语法
以下是 min() 方法的语法:
min( x, y, z, … )

max() 方法返回给定参数的最大值，参数可以为序列。
语法
以下是 max() 方法的语法:
max( x, y, z, … )

6.4 len sum

len() 计算字符串或数据长度
sum() 将列表或元组的数据进行求和

6.5 shorted reversed

sorted 语法：
sorted(iterable, cmp=None, key=None, reverse=False)
参数说明：
iterable – 可迭代对象。
cmp – 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。
key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse – 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
**reverse() **函数用于反向列表中元素。
语法
reverse()方法语法：
list.reverse()

6.6 all any

all() 全为真返回True，否则返回
元素除了是 0、空、None、False 外都算 True。

any() 有一个为真就返回真
元素除了是 0、空、FALSE 外都算 TRUE。

6.7 enumerate()

返回一个枚举对象，它的功能就是将可迭代对象的每个元素从零开始共同构成一个二元组的序列

season=["spiring","summer","fall","winter"]
enumerate(season)
<enumerate object at 0x0000023BF12E1A40>
season
['spiring', 'summer', 'fall', 'winter']
list(enumerate(season))
[(0, 'spiring'), (1, 'summer'), (2, 'fall'), (3, 'winter')]

6.8 zip()

zip()函数用于创建一个聚合多个迭代对象的迭代器。它会将作为参数的每个可迭代对象依次组合成元组

x=(1,2,3)
y=(4,5,6)
zip(x,y)
<zip object at 0x0000023BF12E1A40>
list(zip(x,y))
[(1, 4), (2, 5), (3, 6)]

6.9 map()

map()函数，相当于一个迭代器，对每一个数进行指定的加工，然后迭代。
很不好理解吧，看个程序就懂了

map(pow,(5,6,7),(2,2,2))
<map object at 0x0000023BF1374C40>
list(map(pow,(5,6,7),(2,2,2)))
[25, 36, 49]

6.10 filter()

过滤的作用，将可迭代对象进行进行过滤，保留符合条件的值
代码如下：

filter(str.islower,"ABCdef")
<filter object at 0x0000023BF1377D60>
filtered=filter(str.islower,"ABCdef")
list(filtered)
['d', 'e', 'f']

6.11迭代器和可迭代对象的区别

前文中说了很多迭代器和可迭代对象的名词，那具体这两个有什么区别呢？迭代器只能使用一次，可迭代对象可以重复使用

maped=map(pow,(5,6,7),(2,2,2))
for each in maped:
    print(each) 
25
36
49
list(maped)
[]

map生成的就是一个迭代器，这里可以看到，maped被调用一次后，就变为了空
而可迭代对象是可以重复使用的，如字符串，列表，元组均为可迭代对象

6.12 iter()

iter的作用为：将可迭代对象变成迭代器

x=["asf",5,6,7]
y=iter(x)

7 字典

字典就是一个一一对应的关系，其实列表能实现的功能Python也能实现，只不过在某些功能的实现下，如映射：字典的效率更高，使用起来也更简洁

7.1 字典的定义

可以用“{}”和“:”来定义字典
其中“:”左侧为字典的键，“:”右侧为字典的值
字典一共有六种定义方法，下面一一介绍

a={"关羽":"关习习"，"吕布":"口口布"，"刘备":"刘Baby"}
b=dict(吕布="口口布",关羽="关习习",刘备="刘Baby")
c=dict([("吕布","口口布"),("关羽","关习习"),("刘备","刘Baby")])
d=dict({"关羽":"关习习","吕布":"口口布","刘备":"刘Baby"})
e=dict({"关羽":"关习习","吕布":"口口布"},刘备="刘Baby")
f=dict(zip(["吕布","关羽","刘备"],["口口布","关习习","刘Baby"]))

以上六种方法是等价的

7.2 字典的增删改查

7.2.1 增

formkeys方法用于创建一个新的字典，用序列中的元素作为字典的键，第二个参数为字典对应的值
程序如下

a=dict.fromkeys("张曾洋",666)
print(a)
{'张': 666, '曾': 666, '洋': 666}

另外一种增加的方法：

a['牛逼']=999
a
{'张': 666, '曾': 666, '洋': 666, '牛逼': 999}

7.2.2 删

可以用pop、del、clear三种方法进行删除字典的内容
具体使用方法和序列基本相同，这里不做赘述

7.2.3 改

update是修改字典的常用方法
实现如下:

a.update(了="999")
a
{'张': 666, '曾': 666, '洋': 666, '牛逼': 999, '了': '999'}

7.2.4 查

查找字典中指定的元素一共有两种方法
1.可以直接查找

a['张']
666

但是如果没有需要查找的值，回报告异常，使用下面的方法就可以解决
2. get

a.get('得劲',"没有这个元素")
'没有这个元素'

7.3 视图对象的获取

7.3.1 items()

键值对的视图对象

7.3.2 keys()

键的视图对象

7.3.3 values()

值的视图对象

7.4字典的嵌套

很简单，不说了

8 集合

Python中所学到的集合，与高中学的集合，在概念上并无差异
集合最重要的特点
唯一性，集合中每个元素不会重复
无序性，集合无法使用下标进行索引

8.1 集合的定义

参考如下
集合的定义有三种方法

a={"one"}
{b for b in "FishC"}
set("FishC")

8.2 集合的常用函数

函数名	功能
isdisjoint	检验有无关联
issubset	检验是否为子集
issuperset	检验是否为超集
union	并集，将A、B两个集合合并为一个集合
intersection	交集，将两个集合相同的部分输出
difference	差集，将两个集合不同的部分输出
symmetric_difference	对称差集，A与B相同的排除，剩下的集合
intersection_update(others)	取相同部分，然后进行迭代
difference_update(others)	取不同部分，对集合进行进行迭代
symmetric_difference_update(others)	对称差集的迭代

8.3 不可变集合

frozenset

9 函数

9.1函数的定义

def div(x,y):
	if y==0:
		return"除数不能为零"
	else:
		return x/y

9.2函数的参数

9.2.1 位置参数

根据位置对应参数进行输入

def resver(a,b,c):
    print(c,b,a)
      
resver("整活人","当年","不见")
不见 当年 整活人

9.2.2 关键字参数

将实参进行形参的对应在输出
说不太明白，直接看程序吧

resver(c="整活人",b="当年",a="不见")
整活人 当年 不见

这里需要注意，位置参数和关键字参数可以混合输入，但要求位置参数在关键字参数的前面

9.2.3默认参数

在定义参数的时候，将形参提前进行输入

def resver(b,c,a="整活人"):
    print(c,b,a)
resver("当年","不见")
不见 当年 整活人

此时如果没有输入实参，那么就会输入默认的参数

9.2.4 收集参数

收集参数，即参数的数量不需要定义，实质上参数是以元组的形式保存的
如print()的参数就是收集参数

def collect1(*args):
    print("参数的数量",format(len(args)))
    print("第二个参数是",format(args[1]))
collect1(1,2,3,4)
参数的数量 4
第二个参数是 2

用“*”即可定义形参

9.3局部变量和全局变量

没啥说的，很简单，有一些函数需要了解

9.4 函数的闭包

函数有一种记忆的功能，可以记忆函数的参数

9.5 函数的装饰器

10 __init__函数

1.用处一
在python3.3版本之前在调用，本地创建的包时，必须使用__init__函数，否则无法调用，3.3版本以后，可以不用，但是在调用包的时候必须加入对应的文件名，否则还是无法调用
例子：
我在本地文件 things/fun 下定义了一个函数eat()
那么当我没有加__init__函数时，调用方法如下

#没有加__init__函数时
from thing.fun import eat
eat()

#加__init__函数时
from thing import eat
eat()

跟没加__init__的对比，少了一个.fun
虽然说看起来没啥效果，但是更有利于封装

2.用处二

类似于C++的构造函数，在__init__中加入函数，下次再引入包的时候，就会执行一次这个语句，类似于初始化的作用