|学完Python，学习总结？

文章图片

文章图片

了解Python

Python之父 Guido Van Rossum ，一位荷兰程序员，在1989年圣诞节编写了Pyhon语言。
1991年第一个Python解释器诞生，由C语言编写
2000年Python2.0诞生
2008年Python3.0诞生
2020年Python2.0停止维护， Python3.0更加简洁
Python是一门高级面向对象的编程语言，是动态解释性语言，拥有优雅的结构和清晰的语法，简单易学。提供了丰富的第三方库。 Python也可以调用其他语言的代码，又称为胶水语言。
Python的使用领域非常多，人工智能、数据科学、编写系统工具、APP、自动化脚本、WEB开发等…

Python基础语法

注释

使用 #注释内容号实现单行注释
使用 “”\" 注释内容 “”\"” 三引号实现多行注释

导入库

导入模块 import os
导入模块中的对象 from os import getcwd
导入模块并起个别名 import pandas as pd

变量使用

Python中变量名（标识符）由字母数字下划线组成，并且不能以数字开头，不能和关键字重名
查看Python中的关键字 keyword.kwlist或者 help(“keywords”)
Python中变量根据作用域范围分为全局变量（整个模块内使用）和局部变量（在定义的方法和函数内使用）

执行顺序
Python语句自上而下执行
缩进格式
Python使用缩进区分代码块，缩进可以是 n >=1 ，全局要保持一致
基础函数

函数名	函数功能
help()	查看帮助信息， help(print)
dir()	查看函数的属性和具有的方法， dir(print)
id()	查看标识符的内存地址， a = 1 print(id(a))
type()	查看数据类型
del()	删除对象
input()	接受输入，输入类型为字符串
len()	查看对象长度

Python数据结构

Python中内置的数据结构有六种：Number（数值）、String（字符串）、List（列表）、Tuple（元组）、Dictionary（字典）、Set（集合）。除此之外还有数组、矩阵等结构需要导入工具包才能使用。

数值Python3 里支持 int、float、bool、complex（复数）几种类型的数值

print(a / b) : 得到 a 除 b 的浮点数值
print(a // b) : 得到 a 除 b 的整数值
print(a ** b) : 得到 a 的 b 次方数值

字符串Python中字符串是由一个或多个字符组成的序列，字符个数即为字符串长度。注意Python中没有字符类型，单个字符被认作长度为1的字符串。

创建字符串：使用单引号或者双引号创建的字符串完全一样，三引号字符串可以是多行字符串，如下图
转义字符：使用单引号或者双引号创建多行字符串时可以使用转义字符 \ 实现，还可以使用 \\ 屏蔽特殊符号功能
原始字符串：在字符串前面加 r ，打印最原始字符串， S = r\"P\\y\\thon\"
访问字符串元素：通过下标访问，字符串是一个有序且不可变的结构
字符串加法和乘法：加法用于拼接，乘法用于重复
字符串切割操作：str.split(str1) 以str1为分隔符对字符串切割
字符串替换操作：str.replace(str1 str2) 将字符串中的 str1 替换成 str2 生成新的字符串
字符串大小写转换：str.lower() 将字符串中的大写字符转换成小写， str.upper() 将字符串中的小写字符转换成大写
字符串拼接：str.join(iter) 将所给参数 iter 中的每个元素以指定的字符串 str 连接生成一个新的字符串
格式化输出：使用格式化操作符 % 辅助实现格式化输出，如 print(“My name is %s age is %d.” %(‘Python’ 31))

列表列表是一个序列，其中的元素可以是任意的数据类型，并且可以随时地添加或删除元素。
List = [1 2 3
#创建列表List[1
#访问元素List[1
= 0 #修改元素print(List) #打印 [1 0 3
1234

列表运算符
列表中的运算符和字符串中的相同，如下代码

a = [1 2 3
b = [4 5
print(a * 2) #打印 [1 2 3 1 2 3
print(a + b) #打印 [1 2 3 4 4
1234

列表数据操作

类成员函数	功能
list.append(obj)	在列表末尾添加新的对象
list.remove(obj)	移除列表中的某一个值的第一个匹配项
list.insert(index obj)	将指定对象 obj 插入指定位置 index
list.pop([index = -1 )	移除列表中对应下标位置的元素，默认是最后一个位置
list.reverse()	逆置列表中的元素
list.sort(cmp=None key=None reverse=False)	cmp为可选参数，如果指定了该参数，会使用该参数的方法进行排序。 key是用来进行比较的元素。 reverse=False 为升序
enumerate(list)	遍历并获取元素和对应索引，一般用于for循环中
squares = [x*2 for x in list	列表推导式，批量生成符合规则的元素组成的列表

# 遍历并获取元素和对应索引animals = ['dog' 'cat' 'fish'
for i in enumerate(animals):
print(i)1234

(0 ‘dog’)
(1 ‘cat’)
(2 ‘fish’)

# 列表推导式squares = [x*2 for x in animals
print(squares)123

[‘dogdog’ ‘catcat’ ‘fishfish’

列表索引与切片
索引的访问从 0 到 n-1 ，所有有序序列都能使用
切片List[start : end : step
， start 为 0 时可以省略， end 为 n-1 时可以省略， step 为1时以省略，
注意：step 取负值时，反向取值

元组元组是一个不可变的有序序列，类似于字符串，但不同的是，元组中的对象可以是任意对象。
Tuple = (1 ['a' 'b'
\"Python\") #创建元组print(Tuple) #打印 (1 ['a' 'b'
'Python')print(type(Tuple)) #打印 <class 'tuple'>123

创建单个元组需要使用“” 来标明是元组
元组不可变，修改数据会报错，不推荐变相修改元组数据

t1 = (1)t2 = (1)print(\"t1 type: \" type(t1) \"\\" \"t2 type: \" type(t2))123

t1 type: <class ‘int’>
t2 type: <class ‘tuple’>

字典Python中字典的每个元素由一组键-值对组成，其中键是唯一不可变的，如果字典有相同的键，则后面的值会覆盖前面的值。当数据量大时，字典的访问速度比列表快。

字典的定义

# 字典的三种赋值操作x1 = {'name':'Caso' 'age':18 'sex':'man'x2 = dict(name = 'Caso' age = 18 sex = 'man')x3 = dict([(\"name\" \"Caso\") (\"age\" 18) (\"sex\" \"man\")
)print(x1)print(x2)print(x3)1234567

{‘name’: ‘Caso’ ‘age’: 18 ‘sex’: ‘man’
{‘name’: ‘Caso’ ‘age’: 18 ‘sex’: ‘man’
{‘name’: ‘Caso’ ‘age’: 18 ‘sex’: ‘man’

获取字典数据

# 1.直接使用键获取值，输入不存在的键会报错print(x1['name'
)# 2.使用 get(key [\"str\"
) 方法获取数据print(x1.get(\"age\"))# 2.1 使用 get 获取值时，键值不存在会返回 None 或指定的值print(x1.get(\"school\"))print(x1.get(\"school\" \"school not exist\"))# 3.查看所有的键print(x1.keys())# 4.查看所有的值print(x1.values())# 5.查看所有的键值对print(x1.items())12345678910111213

以上代码输出如下：

Caso
18
None
school not exist
dict_keys([‘name’ ‘age’ ‘sex’
)
dict_values([‘Caso’ 18 ‘man’
)
dict_items([(‘name’ ‘Caso’) (‘age’ 18) (‘sex’ ‘man’)
)

向字典插入数据

x1[\"school\"
= \"爱丁堡\"print(x1)12

{‘name’: ‘Caso’ ‘age’: 18 ‘sex’: ‘man’ ‘school’: ‘爱丁堡’

修改字典中数据

x1[\"age\"
= 25print(x1)12

{‘name’: ‘Caso’ ‘age’: 25 ‘sex’: ‘man’ ‘school’: ‘爱丁堡’

集合【|学完Python，学习总结？】Python集合中的元素是唯一的，重复的元素会被删除。

定义集合

keyset = {'name' 'age' 'sex' 'school'# 使用 in 检查某一元素是否存在print(\"score\" in keyset)123

False

添加元素

# set.add(obj) 给集合添加元素，如果该元素已存在，则不执行任何操作keyset.add('name')keyset.add('score')print(keyset)1234

{‘score’ ‘name’ ‘school’ ‘sex’ ‘age’

删除元素

# set.remove(obj) 移除集合中的指定元素keyset.remove('name')print(keyset)123

{‘score’ ‘school’ ‘sex’ ‘age’

集合唯一性

Test = [1 2 3 2 3 5
# 利用集合的唯一性给列表去重print(list(set(Test)))123

[1 2 3 5

Python控制流Python中的控制流关键字 if、elif、else、for、while、break、continue.
if 判断语句Python中的条件控制通过判断条件语句的执行结果是（True or False）来决定所执行的代码块；有多个代码块可以用 if - elif - else ，如下：
# 是不是狗？game = input(\"请输入: \")if game == 'Dog':
print(\"Oh you're True Dog!\")elif game == 'not Dog':
print(\"hh you're not Dog! Congratulation!\")else:
print(\"Ok you are man?\")12345678

需要注意一点，在Python中 0、None、空值均默认为False ，其他都为Truefor 循环语句Python中for循环不同于其他语言for循环一点就是，它能接受可迭代对象（如序列）作为其参数，每次迭代其中一个参数。
for循环后面还可以加else ，在循环结束后正常执行。
for i in ['you' 'are' 'true' 'dog'
:
print(i)else:
print(\"算了，不和狗计较！\")1234

you
are
true
dog
算了，不和狗计较！

Python中的嵌套循环， eg：输出乘法口诀表
for i in range(1 10):
for j in range(1 i+1):
print(\"%dX%d=%-2d\"%(j i j*i) end=\" \")
print()1234

1X1=1
1X2=2 2X2=4
1X3=3 2X3=6 3X3=9
1X4=4 2X4=8 3X4=12 4X4=16
1X5=5 2X5=10 3X5=15 4X5=20 5X5=25
1X6=6 2X6=12 3X6=18 4X6=24 5X6=30 6X6=36
1X7=7 2X7=14 3X7=21 4X7=28 5X7=35 6X7=42 7X7=49
1X8=8 2X8=16 3X8=24 4X8=32 5X8=40 6X8=48 7X8=56 8X8=64
1X9=9 2X9=18 3X9=27 4X9=36 5X9=45 6X9=54 7X9=63 8X9=72 9X9=81

while 循环语句Python中的while语句，在循环条件成立下，执行循环体，也可以加else语句。
Python中没有 do-while 语句。
game = ['life' 'is' 'True'
i = 0while i < 3:
print(game[i
)
i += 1else:
print(\"未完待续...\")1234567

life
is
True
未完待续…

break 和 continuePython中使用break跳出当前循环，使用continue跳过当次循环
while True:
game = input(\"请承认自己很狗!\\")
if game == \"你是真的狗\":
print(\"好吧，确实狗！\")
break;
else:
print(\"不承认是吧？直到你承认！\")
continue
print(\"反正你到不了这里！\") # 要么break ，要么continue123456789

Python函数自定义函数 def自定义一个函数，返回一个序列，使得序列中每个数字都是前两个数字之和（斐波那契数列）
def fibs(nums):
result = [0 1
;
for i in range(2 nums):
val = result[i-1
+ result[i-2

result.append(val)
return resultprint(fibs(5))1234567

[0 1 1 2 3

Python函数中的几种传参方式：

参数类型	传入方式
必备参数	必须以正确的顺序传入函数，调用时的数量必须和声明时的一样
关键字参数	函数调用时以等号赋值的形式传入
默认参数	调用函数时，缺省参数值如果没有传入，则被认为是默认值
不定长参数	声明时不会命名。如 args、*kwargs ，加号的args是元组，加**号的kwargs存放命名参数，形如key=value的参数， kwargs为字典

def func(a=1 b=2 *args):
print(a b)
print(args)# 1. 传必备参数func(0 4)# 2. 传关键字参数func(b=4 a=0)# 3. 传默认参数func()# 4. 传不定长参数func(1 2 3 4 5)1234567891011

0 4
()
0 4
()
1 2
()
1 2
(3 4 5)

匿名函数 lambdaPython中lambda用来创建匿名函数，相比于普通函数，匿名函数只是一个表达式，函数体比def简单，只能封装有限的逻辑。
max = lambda xy : x + ymax(2 3)12

5

Python对象Python中创建类使用关键字class ，并且具备封装、多态和继承的特点。
class Person(object):
def __init__(self age name): # self指实例化的对象
self.__age = age;
self.name = name def show(self):
print(\"My name is %s\"%(self.name))
print(\"age: %d\"%(self.__age))# 实例化对象p1 = Person(age=18 name=\"dog\")p1.show() # Python的继承class Man(Person):
pass# 子类实例化man = Man(age=25 name=\"Caso\")man.show()12345678910111213141516

My name is dog
age: 18
My name is Caso
age: 25

默认情况下，属性在Python中都是 public 公有的，该类所在的模块或其他导入了该类的模块都可以访问到。如果想要类中某些属性不想被外界访问或继承可对其私有化。

在属性或方法前加一个下划线_ ，可防止该属性被导入到其他模块使用，只在当前模块使用
在属性或方法前加两个下划线__ ，实现完全私有化，类外不能访问

Python 文件读写Python中内置了读写文件的函数：open ，返回文件对象。
通常用法：open(filename mode encoding)

参数值	参数说明
filename	传入要访问的文件名称的字符串值
mode	设定打开文件的模式（r：只读、w：写入、a：追加、*b：二进制的形式）
encoding	打开文件的编码格式，默认为 utf-8

f = open(\"text.txt\" 'w') # 打开文件text.txt ，当文件不存在时会新建一个str = input(\"输入要写入的内容: \")f.write(str) # 将str内容写入文件f.close() # 关闭该文件描述符1234

E:>type text.txt
Caso_卡索

f = open(\"text.txt\" 'r')print(f.read(6)) # 读取6个字符，并将光标后移6个字符print(f.read()) # 读取光标所在位置至最后f.close()1234

Caso_卡
索

# 使用with语句进行文件写入with open(\"test.txt\" 'w') as f:
f.write(\"使用with语句进行文件写/读\")# 使用with语句读取文件内容with open(\"test.txt\" 'r') as f:
print(f.read())123456

使用with语句进行文件写/读

Python 异常捕获程序异常，一般指运行时出现错误（比如被除数为零、列表下标越界、修改字符串等）， Python中用于处理异常的关键字有 try、except、final 等。
# 使用 try、except、final 示例程序异常捕获try:
print(1/0)except Exception as e: # Exception 常规错误的基类
print(e)finally: # 退出try时总会执行
print(\"最后都会执行finally中的语句\")1234567