Python3复习笔记 (万字长文+纯手打+输出已验证)

1. Install python3 & pycharm

2. 设置&HelloWord

print("Hello Word")

3. 画一个形状

作者希望可以介绍python的基本情况；

print("^ ^")
print("———")

4. 变量和数据类型

• 在Python中没有声明语句，只有赋值语句，变量命名规则推荐使用lower_case_with_underscores

作者提出使用一个变量管理年龄等信息，可以方便进行更改；

myName = "Wangdali"
print("My name is "+ myName)

作者介绍了字符串的概念，即纯文本；
若需要储存数字，不需要添加引号；
bool类型；

5. 使用String

即纯文本；

print("Giraffe\nAcademy")//换行了
print(phrase+"is cool")

作者介绍了一种字母大小写的转换和检测的方法and so on：

myName="Wangdali"
print(myName.isupper())#全大写则返回真值；
print(myName.upper())#转换为大写；
print(myName.lower())#转换为小写
print(myName.lower().islower())
print(len(myName))#python会吐出myName的字符数；
print(myName[0])#获得字符串的索引，即第一个字符；
print(myName.index("W");#索引函数，查找string中某个字符的位置；
print(myName.index("dali");#索引函数，查找string中一串字符的位置；
print(myName.replace("dali","hhAlex");#再字符串中，后者将替代前者

正如你所看到的，”point plus 函数“ 还有很多：

6. 数字

作者提到，数字非常有用；结合括号；

print(-123.456)#对negative number也是适用的；
print(3+4.5)#可以进行四则运算；
print(3+4*5)#测试结果为23；
print((3+4)*5)#
print(10%3)#ten mod three,即remainder
myAge=20
print(str(myAge))#把数字转化成字符串

python不允许数字和string 直接相连；
例：

myAge=5
print(myAge+" is myAge")
#打印结果是错误的

应该把数字转化成字符串，再相连；

myAge=5
print(str(myAge)+" is myAge")

myAge=5
print(abs(myAge))#打印绝对值
print(pow(myAge,5))#打印幂次；
print(max(4, 6, 7 , 8 ))#返回较大的
print(min(4,6))#返回较小的；
print(round(4.5))#四舍五入

import的用法

from math import *
print(sqrt(36)) #开平方

7. 来自用户的输入

为了增加与用户的互动性；

name=input("Enter your name: ")#取用户输入的值，存储到name中;其中name是字符串类型；
print("hello ！"+ name)

8. 建立一个基本的计算器

作者希望用户键入数字，进行计算，然后打印；
这是我的第一次尝试：

num1=input("请输入第一数字")
num2=input("请输入第二个数字")
result=num1+num2
print("结果是"+str(result))

看起来这不是我们希望的答案；
因为num都是字符串类型，+进行连接；获得的是二者的拼接；
所以，我们要把键入的num由string转变为数字类型，这需要一个小function

num1=input("请输入第一数字")
num2=input("请输入第二个数字")
result=int(num1)+int(num2)#此处
print("结果是"+str(result))
#这样也许是我们所希望的；

但当我键入一个float类型时，error；

num1=input("请输入第一数字")
num2=input("请输入第二个数字")
result=float(num1)+float(num2)#此处
print("结果是"+str(result))
#这样也许是最合适的basic calculator;

9. 一个基础的游戏

作者通过crazy libs引入；
他希望可以通过用户键入的几个基础信息，以整蛊游戏的方式展示出来
因为为前几个知识点的整合联系，这里不进行演示。

10. 列表

作者希望通过列表来管理和组织信息；允许组织和跟踪他们，在程序中使用他；

friends=["Alex","Kim","jackle"]

当然，你可以在一个列表中存储不同的数据类型；python对此非常友好；
例如

info1=["Alex",19,True]
print(info1)

除这个特性之外，

friends=["Alex","Kim","jackle"]
print(friends[0])#打印friends数组索引元素；
print(friends[-1])#negative num，打印值为”jackle“，即倒数第一个；即倒数的索引元素；
print(friends[1:])#将打印index从1到最后的所有元素值；
print(friends[0:2])#将打印0~1的，不包括index=2的所有元素；
friends[1]="NotKim"#修改数组元素值；
print(friends[1])

作者希望可以通过使用basic function 来帮助你更好地使用和管理列表；笔者也补充了某些功能的另一些实现方法；

#增加元素
friends=["Alex","Kim","jackle"]
num=[2,7,4]
friends.extend(num) #拼接；friends后接num；
friends.append("Jim")#添加元素
friends.insert(1,"Karen")# 插入；在index=1的位置上插入Karen；

#删除元素
friends=["Alex","Kim","jackle"]
friends.remove("Kim")#移除特征元素；
friends[1:2]=[]#也可以直接赋NULL
print(friends)

friends.clear()#清空列表；
friends[:]=[] #也可以这样清除列表；
friends.pop()#去掉列表中最后一个元素；
print(friends)

#如果我想查找一个朋友是否在名单里，
print(friends.index("Kim")) #如果不在名单中将会报error；

print(friends.count("Kim"))#将会打印列表中Jim的数量；
print(len(friends))#也可以输出数量；

#也许我的朋友也有权值，要排序；
print(friends.sort())#元素按照首字符排序，升序；
print(friends.reverse())#元素按照首字符排序，降序；

#嵌套列表
friends=["Alex","Kim","jackle"]
num=[2,7,4]
merge=[friends,num]
print(merge)
print(merge[1][1])

#创建副本；
friends2=friends.copy()

12. 元组（topal）

python中元组和列表类似，区别在于元组中元素不可更改；

#创建一个空元组
tup1=()
#当元组中只包含一个元素时，需要在元素后面添加逗号
tup1=(100,)
#访问元组
tup1=('Google','Baidu','Huawei')
print(tup1[0:1])#将会打印tup1元素

coordinate=（4，5）#赋予坐标以值；
#作者尝试改变元组某一元素数值
coordinate[1]=10
print(coordinate[1])
#python提示error！
#如果使用列表，即[]可以进行改动；但一般情况下人们不喜欢改动数据，尤其是坐标数据；
#人们喜欢这样使用表结构：
coordinates=[(4,5),(6,7),(8,9)]
#删除元组
tup1=('Google','Baidu','Huawei')
print(tup1)
del tup1
print(tup1)#控制台提示error
#元组运算符
len(tup1)#打印元组元素个数
tup1+tup2#连接两个元组
tup1*4#复制；打印四边元组内容；
print("Baidu"in tup1)#返回值为1，则存在；
for i in tup1: #迭代;其中i无需赋初值；
	print i
#元组的索引和截取
tup1=('Google','Baidu','Huawei')
print(tup1[1])#读取第二个元素
print(tup1[-1])#读取反向第一个元素
print(tup1[1:])#读取从第二个元素之后的所有元素
#元组内置函数
tup=('Google','Baidu','Huawei')
print(len(tup))#打印长度
print(max(tup))#打印最大值
print(min(tup))#打印最小值
list1=['Google','Baidu','Huawei']
print(tuple(list1))#把列表转换成元组
operator(tup1,tup2)#比较两个元组元素；
#operator的具体用法暂不展示；

13. 函数

1. 作者希望使用函数来管理代码，这就像一个个的核心；
2. Python定义函数使用def关键字；
3. 函数变量的作用域：局部&全局

def say_hi():
	#注意：一定要注意缩进；这对python很重要；
	print(("Hello Wangdali")
	#当然，我们需要调用函数来使函数正确の被执行；
say_hi()

当然，作者希望用户可以键入信息以丰富函数，这会使他丰富多彩；

def say_hi(name):
	print("Hello "+name)
say_hi("Mike")

关键字参数

def my_info(name,age=20,gender=True):
	print("name: ",name,end= " ")
my_info('Wangdali', ,False) #Error：invalid syntax
#笔者尝试解释调用函数中必须要传值的特点；在咨询后得到答复:需要构建重载函数，否则无法。
#以下是从某blog上扒的与Python重载有关的例子,也许可以很好地解释这种现象；
from functools import singledispatch
 
@singledispatch
def connect(address):
    print(f' 传输参数类型为：{type(address)}，不是有效类型')
 
@connect.register
def _(address: str):
    ip, port = address.split(':')
    print(f'参数为字符串，IP是：{ip}, 端口是：{port}')
 
@connect.register
def _(address: tuple):
    ip, port = address
    print(f'参数为元组，IP是：{ip}, 端口是：{port}')
 
connect('123.45.32.18:8080')
connect(('123.45.32.18', 8080))
connect(123)

返回值

def Multiply(a,b):
	c=a*b
	return c
print(Multiply(3,4)) #打印结果为：12
#我试图让他返回空值；
def Multiply(a,b):
	c=a*b
	return 
print(Multiply(3,4)) #控制台打印结果为：None

可变参数列表

1. 这是一个较不常用的功能，可以让函数调用可变个数的参数
2. 这些参数被包装进一个元组（查看元组和序列）
3. 在这些可变个数的参数之前，可以又零到多个普通的参数

def Add (*args):
    num=0

    if(len(args))==0:
        return 0
    else :
        for i in args:
            num+=i
        return num
print("总和是： ",Add(1,2,3,4,5,6)) #注意，列表不用添加[]

匿名函数

(lambda x: x > 2)(3)     #True
(lambda x, y: x ** 2 + y ** 2)(2, 1)   #

14. return

例：

def Multiply(num):
	return num*num
	#return之后接下来的不会输出；
	print("输出这行代表我一天能挣一爽")
	
print(Multiply(4))

作者也试图从函数的返回值获取信息；这和用户键入信息一样，能帮助我们丰富程序，完善用户体验；

15. if

作者希望把生活中基本的判断逻辑添加到程序的编写中；

注意：

1. Python中使用elif 代替 else if ；所以 if语句的关键字为 if- elif - else
2. 每个条件之后要用：
3. 使用缩进来划分语句块
4. 在Python中没有switch - case语句

例：

is_male=1
is_tall=0
if is_male and is_tall:
	print("Yes,You are right")
elif is_male and not(is_tall):
	print("Come on!")
elif is_male or not(is_tall):
	print("Come on!")
else 
	print("Come on!")
#不考虑逻辑

作者将该脚本保存在Come.py文件中，并执行该脚本

python Come.py

• if 可以是表达式，就像C语言中的用一个三元运算符？
• "yahoo!" if 3>2 else 2

16. if & 比较

作者希望通过不同的策略实现if的判断和比较；而不是仅仅通过True&False；

def max_num(num1,num2,num3):
	if num1>=num2 and num1>num3:
		return num1
	elif num2>num3 and num2>num1:
		return num2
	else :
		return num3
print(max_num(1,2,3))

当然，不仅仅是数字可以被比较

if str1>=str2 and str1>str3:

17. 进阶的计算器设计

较之于初步的设计方案，作者希望用户键入运算方式，获得他们满意的运算结果；

num1=float(input("Enter first number: "))
#作者为什么这样写？通常在python中，无论我们从用户哪里得到的输入是什么，都会被转换成字符串形式，但我们需要数字形式；所以将input数据转换成float类型，这是非常合适的；
op=input("Enter operator: ")
num2=float(input("Enter first number: "))
#作者通过一连串的检查来判定运算方式
if op=="+":
	print(num1+num2)
elif op=="-":
	print(num1-num2)
elif op=="*":
	print(num1*num2)
elif op=="/":
	print(num1/num2)
else :
	print("invalid operator")

18. 字典

字典中每一个键值对用：连接；相邻用，连接；整个字典在{}中；

dic={1:'Wangdali',2:'Alex',3:'Jim'}
print(dic)

其中，键是不重复的，但值不必；键的数据类型是不可变的，如字符串，数字，元组（注意：List是可变的，不能使用）；值不必；

dict={True:'Wangdali',78:"Jim",'J':860}
print(dict)
#访问字典里的值
print("输出78对应的字典值为："+ dict[78])#相同类型的同时输出可以加+
print("输出'J'对应的字典值为：", dict['J'])#不同类型的同时输出要加，
#如果字典中没有访问数据
dict={True:'Wangdali',78:"Jim",'J':860}
print(dict)
print("输出76对应的字典值为："+ dict[76]) #提示keyError
#修改字典
dict={True:'Wangdali',78:"Jim",'J':860}
dict["Jim"]="JJJJJJim"
print("Jim : ",dict['Jim'])
#添加键值对
dict={True:'Wangdali',78:"Jim",'J':860}
dict["Alex"]="AlexWang" #直接赋值，即可添加；
print("Alex对应的键值 : ",dict['Alex'])
#删除字典元素
dict={True:'Wangdali',78:"Jim",'J':860}
dict.clear()#直接清空字典
del dict[78] #删除字典中某一元素
print (dict)

字典键的特性
1、不允许同一个键出现两次，否则应用后一个值；

dict={True:'Wangdali',78:"Jim",'J':860，78:'Alex'}
print (dict)

2、键必须不可变，用列表作为键值是非法的

字典内置函数&方法

 len(dict)#输出键的个数
 str(dict)#输出字典以可打印的字符串形式表示
 #返回类型
 dict={True:'Wangdali',78:"Jim",'J':860，78:'Alex'}
 print(type(dict))
 #删除所有元素
 dict.clear()
 #返回一个副本
 dict.copy()
 #创建一个新字典，以序列seq中元素作为字典的键；val作为字典所有键的初始值
dict = {True: 'Wangdali',78: "Jim", 'J': 860}
E=dict.fromkeys(78) #Error：当您尝试迭代整数值时，会引发“'int' object is not iterable”错误。要解决此错误，请确保您正在迭代一个可迭代对象而不是一个数字。现在你已经准备好像 Pythonista 一样解决这个错误了！
print(E)
F=dict.fromkeys('J')
print(F) #输出{'J': None}
#返回指定键的值，如果值不存在则返回default值
dict = {True: 'Wangdali',78: "Jim", 'J': 860}
print(dict.get('J',0))
#判断；如果键在字典中返回True,否则False
print('J'in dict)
#以列表形式返回可遍历的（键，值）元组数组
print(dict.items())
#和get()类似，但如果键不存在于字典中，将会添加键并将值设置为default
print(dict.setdefault('J',0))
#把字典dict2的键值对更新到dict1中
dict1 = {True: 'Wangdali',78: "Jim", 'J': 860}
dict2 = {'J':'Wuyifan',2:'Dianman'}
dict1.update(dict2)
print(dict1)
#以列表返回字典中所有值
dict1 = {True: 'Wangdali',78: "Jim", 'J': 860}
print(dict1.values())

19. 循环

Python中的循环有for 和 while ；
Python中没有 do while 循环

#作者试图通过while计算1~100的总和
max=100
sum=0
i=1
while i<max:
    sum+=i
    i+=1
print('总和为:',sum)
#注意缩进

#for循环
List=[1,2,3,4,3]
for i in List:
	if i==3:
		print("好耶")
		break
	else :
		print("嘤嘤嘤")

range() 函数
如果你需要遍历数字序列，可以使用range（）函数；他会生成数列

for i in range(5):
	print(i) #打印0~4
#当然，你也可以使用range指定区间的值
for i in range(5,9):
	print(i) #打印5~8
#也可以打印negative num
for i in range(-1,-2,-8):
	print(i)
#也可以结合range（）和len() 来遍历一个列表的索引；
a=['Large bowl of wide noodles','WuYifan ','Canadian electric eel']
for i in range(len(a)):
	print(i,a[i])
#也可以使用range()创建列表：
	list(range(5))

其他语句

1. break
2. continue
3. pass #等待键盘中断ctrl+c

20. 迭代器&生成器

1. 迭代是Python最强大的功能之一，是访问集合元素的一种方式
2. 迭代器是一个可以记住遍历的位置的对象
3. 迭代的对象从集合的第一个元素开始访问，直到所有的元素被访问完成结束，迭代器只能前进不能后退
4. 迭代器的两种基本方法：iter() 和 next()
5. 字符串，列表或元组对象都可用来创建迭代器；

list = [1,2,3,4]
it= iter(list) #创建迭代器对象
print (next(it)) #输出1
print (next(it)) #输出2
#迭代器对象也可以通过常规的for语句遍历
list=[1,2,3,4]
it= iter(list)
for i in it:
	#print(i,it[i]) 注意：“list_iterator”对象不可下标
	print(i,end = " ") #添加end，则会横向排列，间隔为一个" ";
#也可以使用next（）函数
import sys #引入sys模块
list= [1,2,3,4]
it=iter(list)
while True:
    try:
        print(next(it))
    except StopIteration:
        sys.exit()

生成器

1. 在Python中，使用了yield的函数被称为生成器（generator）
2. 和普通函数不同的是， 生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器；
3. 在调用生成器运行的过程中，每次遇到yield，函数就会暂停并保存所有的运行信息，返回yield值，并在下一次执行next() 方法时从当前位置继续运行；

#生成fibonacci数列，即：F(0)=0，F(1)=1, F(n)=F(n - 1)+F(n - 2)
import sys
def fibonacci(n): #生成器函数，斐波那契；
	a,b,counter=0,1,0
	while True:
		if(counter>n):
			return
		else:
			yield a
			a,b = b,a+b
			counter+=1
f= fibonacci(10)
while True:
	try:
		print(next(f),end=" ")
	except StopIteration:
		sys.exit()
#输出结果为：0 1 1 2 3 5 8 13 21 34 55

Python的sys模块

1. sys模块提供访问解释器使用或维护的变量，和与解释器进行交互的函数；接提供一系列的函数和变量，用于操控Python运行时的环境

21. 数据结构

1. 在Python中，列表可以修改，但是字符串和元组不可修改
2. 你可以把这一节当作为前面知识的总结和补充；
   方法 | 描述
   list.append(x)|把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]|通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
   list.extend(List)|在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
   list.insert(index,x)|删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
   list.remove(x)|从列表的指定位置删除元素，并将其返回。如果没有指定索引，a.pop()返回最后一个元素。元素随即从列表中被删除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
   list.pop([i])|移除列表中的所有项，等于del a[:]。
   list.clear()|移除列表中的所有项，等于del a[:]。
   list.index(x)| 返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
   list.count(x)|返回 x 在列表中出现的次数。
   list.sort()| 对列表中的元素进行排序。
   list.reverse()| 倒排列表中的元素。
   list.copy()| 返回列表的浅复制，等于a[:]。

注意：类似insert、remove、sort 没有返回值

把列表当作堆栈使用

1. 通过append() 方法将元素添加到堆栈顶部，用不指定索引的pop() 方法可以把元素从堆栈顶部释放出来；

把列表当作队列使用

1. 使用popleft（） 方法让元素从左端释放出来；
2. 这种方法效率低，因为其他的元素要一个一个地移动

列表推导式

1. 他提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列；
2. 每个列表推导式都在for之后跟一个表达式，然后有0或者多个for或if语句，返回结果是一个生成的列表，如果希望表达式推导出元组，就必须使用括号；

#作者试图将列表中的数值乘以三，并打印出来；
List=[2,4,6]
print([3*x for x in List]) #打印结果为[6,12,18]
#当然，亦可以在列表中生成元组元素：
List=[2,4,6]
print([(x,x**2) for x in List]) # 打印结果为：[(2, 4), (4, 16), (6, 36)]
#对序列里的每一个元素调用方法；
Des=[' Wuyifan ',' Xiaozhan ']
print([chara.strip() for chara in Des])#打印结果为['Wuyifan', 'Xiaozhan'] ； 因为 Python中 strip()方法用于移除字符串头尾的指定的字符（默认为空格或换行符）或者字符数列
#使用if作为过滤器
List=[1,2,3,4,5]
print([(x,x**2) for x in List if x>3]) ##注意你是制作一个列表，不要忘记[]，这很重要；
#这是一些关于循环和其他技巧的演示：
List1=[1,2,3]
List2=[2,4,6]
print([x*y for x in List1 for y in List2 ],end='\n')
print([List1[i]*List2[i] for i in range(len(List1))])
#也可以使用复杂表达式或嵌套函数
print([str(round(355/113,i)) for i in range(1,6)])#

嵌套列表解析

#以下涉及到线性代数中矩阵的相关知识，作者暂时不做研究；
#以下展示了3*4的矩阵列表
Matrix=[
    [1,2,3,4],
    [5,6,7,8],
    [5,6,7,8]
]
#实现列表矩阵的转置
[[row[i] for row in matrix] for i in range(4)]
#另外一种列表矩阵的转置方法
>>> transposed = []
>>> for i in range(4):
...     transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
#第三种方法
略

del 语句

1. 使用del 语句可以从一个列表中依照索引而不是一个值来删除一个元素；这个之前使用的pop() 返回一个数值不同，可以用del 语句从列表中删除一个切割，或者清空整个列表，作者之前提到的方法是给该切割赋予一个空列表

#举例
List=[0,1,2,3,4,5,6,7,8,9]
del List[0]
del List[1:2]
del List[:] #清空列表
del List #删除实体变量
print(List)

元组和序列

1. 元组的输入时候也可以没有括号，不过通常都有

集合

1. 集合，无序不重复；他的基本功能包括关系测试和消除重复元素；
2. 可以用大括号（{}）创建集合，不过注意，如果要创建一个空集合，必须使用set() 而不是 {}，后者将创建一个空的字典；

Gather1=set('abcdefab')
Gather2=set('sdsdghjk')
print(Gather1) #打印，结果为 {'c', 'a', 'd', 'b', 'e', 'f'}
print(Gather1-Gather2) #两个字典差集
print(Gather1|Gather2) #两个字典并集
print(Gather1&Gather2) #两个字典交集
print(Gather1^Gather2) #两个字典异或
#集合也支持推导式；
Gather1=set('abcdefab')
Gather2=set('abef')
a= {x for x in Gather1 if x not in Gather2} #注意此处为{}
print(a)

字典

1. 字典是非常有用的Python内建数据类型
2. 键值对集合，一对大括号创建一个空的字典；

tel={'guido': 4127, 'irv': 4127, 'jack': 4098}
print(list(tel.keys())) #输出结果为：['guido', 'irv', 'jack']
print(sorted(tel.keys())) #输出结果为：['guido', 'irv', 'jack']
print('guido' not in tel)
print('guido' in tel)
#构造函数dict（）直接从键值对元组列表中构建字典；如果有固定的模式，列表推导式指定特定的键值对；
tupleInList=[('w',1),('guido',2)]
print(dict(tupleInList)) #输出结果为：{'w': 1, 'guido': 2}
#使用字典推导式可以用来创建任意键和值的表达式词典
print({x:x**2 for x in range(1,5) })
#如果关键字只是简单的字符串，那么使用关键字参数指定键值会更方便；
print(dict(aW=4399, guide=123)) #输出：{'aW': 4399, 'guide': 123}

遍历技巧

1. 在字典中遍历时，键值对可以使用item() 方法同时解读出来

Dict={"wangdali":123,"Da":456}
for i,j in Dict.items():
    print(i,j)

2. 在序列中遍历时，索引位置和对应数值可以通过enumerate（）函数同时得到

List=["Wangdali","Alex"]
for i, num in enumerate(List):
    print(i,num)

3. 同时遍历两个或更多的序列，可以使用zip() 组合

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q,a in zip(questions,answers):
    print("What is your {0}? It is {1} ".format(q,a)) 
    #输出结果为：
 	#What is your name? It is lancelot 
	#What is your quest? It is the holy grail 
	#What is your favorite color? It is blue 

反向遍历序列

1. 首先指定这个序列，然后调用reversed() 函数

for i in reversed([1,2,3]):
	print(i)

顺序遍历序列，使用sorted () 函数返回一个已经排序的序列，

basket = ["bpple","aanana","pear"]
for i in sorted(basket):#会修改原值
    print(i) #
basket = ["bpple","aanana","pear"]
for i in sorted(set(basket)): #不会修改原值；
    print(i)

22. 模块

1. 前几张中我们脚本都是使用Python解释器来编程，如果你从解释器退出再进入，那么你定义的所有方法和变量都消失了。
2. 为此Python提供了一个方法， 把这些定义存放再文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称为，模块；
3. 模块是一个包含所有你定义的函数和变量的文件，后缀是.py 模块被别的程序引入，用来使用该模块中的函数等功能，这也是使用Python标准库的方法。

import sys
print(len(sys.argv))
print("命令行参数如下")
for i in sys.argv:
    print(i)
print("Python路径为：",sys.path)

import 语句
from … import 语句
form … import *

form modname import *
#这种方法可以导入一个模块中所有函数、变量；但是由单一下划线_ 开头的名字不在其中，大多数情况，Python程序员不适用这种方法，因为引入的其他来源的命名，很可能覆盖已有的定义；

name 属性

1. 一个模块被另一个程序引入时候，其主程序将执行；如果我们想在模块被引入时，模块中的某一个程序块不执行，则可以使用_name_ 属性来使该程序块仅在该模块自身运行时执行；

if __name__ == '__main__':
    print("程序自身再运行")
else :
    print("我来自另一个模块")

1. 每一个模块都有一个_name_ 属性，当其值是’main’时，白哦名该模块自身再运行，否则是被引入；
2. __name __ 双下划线；

dir() 函数

1. 内置的函数dir() 可以找到模块内定义的所有名称，以一个字符串列表的形式返回；
2. 如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:

标准模块
包
从一个包中导入*
（这一节内容需要实践）

23. Python3的输入和输出

输出格式美化

String ='Hello Wangdali'
print(str(String))# 返回一个用户易读的表达形式
print(repr(String)) #返回一个解释器易读的表达形式
print(String.format()) #格式化输出值
#format() 的用法之位置
print('{0} and {1}'.format('Wangdali','Alex')) #输出Wagndali and Alex
#如果 format() 中使用了关键字参数，那个他们的值会指向使用该名字的参数
print('{sign1} and {sign2}'.format(sign1='Wangdali',sign2='Alex'))
#位置和关键字参数可以任意的组合

旧字符串格式化
读和写文件

#open() 将会返回一个file 对象
open (filename,mode)
f=open('/tmp/workfile','w') 

24. File 方法

25. OS文件/目录方法

26. 错误和异常

• 我们不推荐try finally 的资源清理方案；而使用with 语句，这是打开文件、网络、数据集的推荐方式；

# retyr finally 方案；
try:
    raise IndexError("This is an index error")
except IndexError as e:
    pass #pass 是一个占位符，什么也不做；
except (TypeError,NameError):
    pass # 你可以处理多种异常；
else:
    print("All Good")
finally:
    print("We can clean up all resources here")

# with 语句
with open("Test.py") as f:
    for line in f:
        print(line)

27. Python3 面向对象

1. 类：用来描述具有相同属性和方法的对象的结合
2. 类变量：定义在类中且再函数体之外；类变量通常不作为实例变量使用；
3. 数据成员：指类变量或者实例变量；
4. 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行方法的改写，这个过程叫做方法的覆盖；
5. 局部变量：只作用于当前实例的类，是定义在方法中的变量；
6. 实例变量：在类的声明中，属性是用变量来表示的。这种变量就称为实例变量，是在类声明的内部但是在类的其他成员方法之外声明的。
7. 继承：即派生类继承基类的字段和方法；继承也允许把一个派生类的对象作为一个基类对象对待；
8. 实例化：创建一个类的实例；即类的具体对象；
9. 方法：类中定义的函数
   10.对象：通过类定义的数据结构实例；对象包括两个数据成员，即类变量+实例变量，以及方法。

类对象

class Myclass:
    i=123
    def f(self):
        return 'Hello'
x=Myclass()
print(x.i)
print(x.f())
#很多类都倾向于将对象构建为有初始状态的，因此类可能会定义一个名为__init__() 的特殊方法，即构造方法；
def __init__(self):
	self.data= [] 
#当然，__init__方法也可以有参数，

//注意这是c++代码，为了方便读者理解，请自行于Python代码进行比较；
#include 
using namespace std;
class Food {
public:
	int num;
	Food(int Num) {
		num = Num;
	}
};
int main() {
	Food food(1);
	cout << food.num;
}

类的方法

1. def关键字可以为类定义的一个方法；与一般函数的定义不同，类的方法必须包含self ，且为第一个参数；

#例：
class food:
    #定义基本属性（也可不写）
    num = ''
    str = ''
    #定义私有属性，私有属性在类外部无法进行直接访问；
    __kind = ''
    #定义构造方法；
    def __init__(self,Num,Str,Kind):
        self.num= Num
        self.str=Str
        self.__kind=Kind
    def eat(self):
        print('本仙男吃了一个食物，好耶！今天也是在逃仙男的一天！yyds！')
food=food(1,'banana','fruit')
print(food.num)
print(food.str)
print(food.__kind) #Error

继承

1. 如果一种语言不支持继承，那么类也就失去了意义；

#单继承示例
class food:
    #定义基本属性（也可不写）
    num = ''
    str = ''
    #定义私有属性，私有属性在类外部无法进行直接访问；
    __kind = ''
    #定义构造方法；
    def __init__(self,Num,Str,Kind):
        self.num= Num
        self.str=Str
        self.__kind=Kind
    def eat(self):
        print('本仙男吃了一个食物，好耶！今天也是在逃仙男的一天！yyds！')

class Son1(food):
    a=''
    def __init__(self,Num,Str,Kind,a):
        food.__init__(self,Num,Kind,Str)
        self.a=a
    def eat(self):
        print('蚌埠住了hxdm')


son1=Son1(1,'banana',6,6)
son1.eat() #输出结果为：蚌埠住了hxdm

#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法        

方法重写

1. 已经用刚才的eat() 函数展示；

类属性和方法

1. 类的私有属性： __private_attrs：两个下划线开头，声明该属性为私有，不能在类地外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。
2. 类的私有方法： __private_method：两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 slef.__private_methods。

类的专有方法

__init__ #构造函数
__del__ #析构函数
__repr__#打印，转换
__setitem__ #按照索引赋值
__getitem__ #按照索引获取值
__len__ #获得长度
__cmp__ #比较运算
__call__ #函数调用
__add__ #加运算
__sub__ #减运算
__mul__ #乘运算
__div__ #除法运算
__mod__ #求余运算
__pow__ #乘方

运算符重载

#作者试图对类的专有方法进行重载
#孩子想早回去就直接copy了呜呜呜别骂了别骂了
#!/usr/bin/python3

class Vector:
   def __init__(self, a, b):
      self.a = a
      self.b = b

   def __str__(self):
      return 'Vector (%d, %d)' % (self.a, self.b)
   
   def __add__(self,other):
      return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)
v2 = Vector(5,-2)
print (v1 + v2) #输出结果：Vector(7,8)