【Python学习笔记—保姆版】第三章—Python流程控制、函数的定义、常见错误、模块与包、类

欢迎访问我搞事情的【知乎账号】：Coffee
以及我的【B站漫威剪辑账号】：VideosMan
若我的笔记对你有帮助，请用小小的手指，点一个大大的赞哦。

#编译器使用的是sypder，其中">>>"代表输入和执行的内容
>>> print('Hello World') #执行代码
Hello World #输出值

流程控制

if-else

分支

 if condition:
   pass
 elif condition:
   pass
 else:
   pass

for 循环

注意”：“，还有空格

for…in…:句型，它可以枚举列表中的所有元素并进行循环处理。

1．基本句型如下：

>>> for i in [2,3,4]: 	print(i,end=',') 

2,3,4,

💡 错误写法：for i in len:

💡正确写法：for i in range(len): ——必须是一个范围

2．for循环可以帮助我们处理字符串，假如我们想要分别输出字符串中的所有字母

>>> for i in 'abcd': 	print(i) 

a b c d

3．for循环经常和range内置函数配合在一起使用，range函数生成一个从零开始的列表，下面的例子可以帮助你理解它

>>> for i in range(3): 	print(i)

0 1 2

4．可以使用for循环来生成列表，我们用range（3）来生成列表[0,1,2]，然后使用循环来计算x的平方，放入列表中

>>> [x**2 for x in range(3)]

[0, 1, 4]

5．还可以设置条件来形成列表，我们可以生成100以内偶数的平方构成的列表

>>> [x**2 for x in range(10) if not x%2] 

[0, 4, 16, 36, 64]

while循环

while 语句基本形式为：

while 判断条件：

执行语句……

执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为true。当判断条件假false时，循环结束。

 i=0
 while i<10: 	
 	print('This is '+str(i))  #将i转化为字符型才能用“+”连接输出 	
	i+=1          #相当如 i=i+1

This is 0
This is 1
This is 2
This is 3
This is 4
This is 5
This is 6
This is 7
This is 8
This is 9

continue/break

continue 跳过这一次执行，进行下一次的操作继续循环。
break 停止执行整个循环

# continue 和 break 用法
#1.将小于10的偶数输出
i = 1
while i < 10:
    i += 1
    if i%2 > 0:   # 非双数时跳过输出
        continue
    print(i)    # 输出双数2、4、6、8、10

#2.输出小于等于10的正整数
j = 1
while 1:      # 循环条件为1必定成立
    print(j)     # 输出1~10
    j += 1
    if j > 10:   # 当i大于10时跳出循环
        break

• 试比较

  >>> i=1
  >>> while i<10: 
  		if i%2 == 0: 
  			continue 	
  		print(i) 	
  		i+=1 
  

  1

  >>> i=1
  >>> while i<10: 
  		if i%2 == 0: 	
  			i+=1
  	 		continue 	
  		print(i) 	
  		i+=1
  

  1
  3
  5
  7
  9

range()函数

可以用range()函数生成一个列表

for i in range(5): 	
	print(i,end=',')

0,1,2,3,4,

range(5),其中参数’5’代表：从0到4的一个序列,即长度为5的一个序列。此遍历也可以一句搞定:

print([i for i in range(5)])

[0, 1, 2, 3, 4]

可以自定义我们需要的起始点和结束点：

list(range(1,5)) #代表从1到5(左闭右开，不包含5)

[1, 2, 3, 4]

💡 说明：在以前的版本中range()函数直接返回一个列表，但在3.5版本中，range()作为一个容器存在，当你需要将它作为列表时，你需要list一下即可，如果你需要将它作为元组，你只需要tuple一下即可。

>>> a=range(5)
>>> list(a)
[0, 1, 2, 3, 4]
>>> tuple(a)
(0, 1, 2, 3, 4)

还可以定义步长,下面我们定义一个从1开始到30结束，步长为3的列表

>>> print('range(1,30,3)表示：',list(range(1,30,3)))
range(1,30,3)表示： [1, 4, 7, 10, 13, 16, 19, 22, 25, 28]
>>> listC =[i for i in range(1,30,3)]
>>> print(listC)
[1, 4, 7, 10, 13, 16, 19, 22, 25, 28]

range()函数也可以倒序，格式：range(a,b,-1)

>>>list(range(5, 0, -1)) 
[5, 4, 3, 2, 1]
>>>list(range(5, 0, -2))  #步长为-2
[5, 3, 1]

列表与元组遍历

• 列表遍历

如果需要遍历一个数字序列，可以是使用python中内建的函数range(), 如下面要遍历一个列表test_list

>>> test_list =[1,3,4,'Hongten',3,6,23,'hello',2]
>>> for i in range(len(test_list)):
print(test_list[i],end=',')

1,3,4,Hongten,3,6,23,hello,2,

• 元组遍历

>>> tup=('abd','123')
>>> for i in range(len(tup)):
	print(tup[i])

abd
123
二元元组的访问

for i in range(len(user)):  
      for j in range(len(user)):  
           print('user['+str(i)+']['+str(j)+']=',user[i][j])

练习

练习3-01

将整数2016的每个数字分离数来，依次打印输出

a=2016
for i in str(a):
	print(i)

结果
2
0
1
6

练习

b_list=list(range(1,101))
while len(b_list)>1:
	b_list=b_list[1::2]
print(b_list[0])

a=input("请输入一个整数：")

while True:
	b=a[::-1]
	s=int(a)+int(b)
	print("{0}+{1}={2}".format(a,b,s99))
	if str(s)==str(s)[::-1] or len(str(s))>100:
		break
a=str(s)

请输入一个整数：99
99+99=198
198+891=1089
1089+9801=10890
10890+09801=20691
20691+19602=40293
40293+39204=79497

水仙花数

法一

for i in range(100,1000):
  a=int(str(i)[0] )
  b=int(str(i)[1])
  c=int(str(i)[2])
  if a**3+b**3+c**3==i:
      print("{0} 是水仙花数".format(i))

153 是水仙花数
370 是水仙花数
371 是水仙花数
407 是水仙花数

函数的定义

（1）在Python中不用指定返回值的类型，另外注意def行尾的“:”；函数的命名一般首字母不要大写，以区别“类”。

（2）函数参数params可以是零个、一个或者多个，同样，函数参数也不用指定参数类型，因为在Python中会自动根据值来维护其类型。

（3）return语句是可选的，它可以在函数体内任何地方出现，表示函数调用执行到此结束；返回的值，也就是输出的功能，return可以返回多个值a,b,c ，以逗号分隔，相当于返回一个 tuple(定值表)，相当于return (a,b,c)。

变量作用域

在函数内部定义的变量作用域都仅限于函数内部，在函数外部是不能够调用的，一般称这种变量为局部变量。

def function():
  x=2
   count=2
   while count>0:
       x=3
       print(x)
       count=count-1 

function()

3
3

还有一种变量叫做全局变量，它是在函数外部定义的，作用域是整个程序。

全局变量可以直接在函数里面应用，但是如果要在函数内部改变全局变量，必须使用global关键字进行声明。

x=2
def fun1():
   print(x)

def fun2():
   global x
   x=3
   print(x)

fun1()
fun2()
print(x)

2
3
3

变量名的引用将依次查找本地、全局、内置变量。

X = 99   
def add(Y):  
   Z = X + Y  
   return Z  
    
print(add(1))

100

X = 88  
def func():  
   global X  
   X = 99  
     
func()  
print(X)

99

y,z = 1,2  
def func():  
   global x  
   x = y + z  
 
func()    
print(x,y,z)

3 1 2

基本形式

def name(args):
    pass
    return value

返回值不需要写类型、首字母不用大写、return回多个值（其实是返回元组

💡 必须先定义，后使用

• 形参与实参

  形参传的是实参的地址，形参地址=实参的地址。函数内重新定义形参，实参地址不变

  💡 形参应用实参

• 全局变量

  global x
  

函数参数的类型（三种参数）

• 位置参数

  通过参数位置传递参数

  def display(b,a):
  print(a)
  print(b)
  display('hello','word')
  

  word
  hello

• 关键字参数

  > 通过形参可以设置默认值
  

  def display(a,b):
  print(a)
  print(b)
  display(a='hello',b='word')
  display(b='word',a='hello')
  

  hello
  word
  hello
  word

  def display(a='hello',b='word'):#设置默认值
  print(a+b)
  display('hellooooooo','word')#位置参数
  display(a='hello',b='word') #关键字参数
  display('helololo')#位置参数 设置第一个
  display()#直接使用默认值
  

  helloooooooword
  helloword
  helololoword
  helloword

  def insert(a,L=[]):#可变类型跳出函数，值仍然保留
  L.append(a)
  print(L)
  insert('hello')
  insert('word')
  

  [‘hello’]
  [‘hello’, ‘word’]

• 收集参数

  > 收集参数可以用于收集0-n个参数
  

  def storename(name,*nickName):
     print('real name is %s' %name)
     for nickname in nickName:
         print(nickname)
  storename('jack')
  storename(u'詹姆斯',u'小皇帝')
  storename(u'奥尼尔',u'大鲨鱼',u'三不沾')
  

  real name is jack
  real name is 詹姆斯
  小皇帝
  real name is 奥尼尔
  大鲨鱼
  三不沾

   '*' 存放在元组，‘**’ 存放在字典
  

  def printvalue(a,*s,**d):
     print(a,s,d)
  
  printvalue(1,2,c=3)
  printvalue(1,3,4,2,c=3,f="l")#后面两个键值对给字典
  

  1 (2,) {‘c’: 3}
  1 (3, 4, 2) {‘c’: 3, ‘f’: ‘l’}

• 函数的多个返回值

  Python中函数是可以返回多个值的，如果返回多个值，会将多个值放在一个元组或者其他类型的集合中返回。

  def function():
     x=2
     y=[3,4]
     return x,y
  
  print(function())
  

  (2, [3, 4])

函数调用

> .在调用文件头引入：from a import *。

#添加以下代买，被调用的时候不会自动执行
if _name_=="_main_":

注1：为了避免导入所有的函数占内存，所以一般用到什么函数导入什么函数，除非导入的比较多，才使用*；

注2：为了防止导入的多个模块中有相同的函数名而引起的混乱，也不建议使用*。

from addyu import add：#从addyu.py文件中导入add(a,b)函数；
from addyu import *：#导入addyu.py文件中所有的函数。

from tel import*
from tel2 import*#容易导致函数名相同，出现冲突

函数式编程

• Lambda匿名函数，也叫行内函数，具体如下：

  f = lambda x : x+2     #定义了一个函数f(x)=x+2
  g = lambda x,y : x+y  #定义了一个函数g(x,y)=x+y
  >>> f = lambda x,y,z:x+y+z
  >>> f(1,2,3)
  6
  lambda只是一个表达式，函数体比def简单很多。其用途：
  1、对于单行函数，使用lambda可以省去定义函数的过程，让代码更加精简。
  2、在非多次调用函数的情况下，lambda表达式即用即得，提高性能。
  

• reduce(func(),Z)

  可以自动执行循环过程

  用传给reduce中的函数func()（必须是一个二元操作函数）先对集合Z中的第1、第2个数据进行操作，得到的结果再与Z中的第三个数据用func()函数运算，最后得到一个结果。如：

  reduce(func(),Z)
  
  from functools import reduce
  def add(x,y):
      return x+y  
  sum=reduce(add,(1,2,3,4,5,6,7))
  print(sum)
  
  

  Reduce就是将add(x,y)函数作用在（1,2,3,4,5,6,7）这个域上，即：1赋给x，2赋给y；再将计算结果(1+2)赋给x，3赋给y；再将计算结果((1+2)+3)赋给x，4赋给y，…依此类推。

• filter() ，需要list一下

  可以自动执行循环过程，筛选作用

  def is_odd(n):
      return n % 2 == 1
  list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
  

  [1, 5, 9, 15]
  把一个序列中的空字符串删掉，可以这么写：

  def not_empty(s):
      return s and s.strip()   #思考and左右能否交换
  list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
  
  #逻辑判断，如果第一个为假，后面就不会判断了
  

  [1, 5, 9, 15]

  用三种方法表达以下效果

  #方法一
  [i for i in range(1,10) if i>5 and i<8]
  
  #方法二
  li=[]
  for i in range(1,10):
      if i>5 and i<8:
          li.append(i)
  
  #方法三（不需要循环）
  list(filter(lambda i:i>5 and i<8,range(1,10)))
  

  [6, 7]

• map(func，s) ,需要list一下

  可以自动执行循环过程，执行函数结果

  函数func在s域上遍历，在python3.x中map()是一个容器，返回的时候需要用list调用一下，才显示数据，显示的是func作用后的结果数据

  print(list(filter(lambda x:x**2, [1,2,3])))
  print(list(map(lambda x:x**2, [1,2,3])))
  

  [1, 2, 3]
  [1, 4, 9]

  💡 reduce,fliter,map 都比循环快得多

• 等效代替

  [k+2 for k in [1,2,3,4] if k % 2 == 0 ]
  #或者
  list(map(lambda x:x+2,filter(lambda k:k%2==0,[1,2,3,4])))
  

  [4,6]

  [x*x for x in range(10) if x%3 == 0]
  #或者
  list(map(lambda k:k**2, filter(lambda  x: x%3==0,range(10))))
  

  [0, 9, 36, 81]

• 随机选择

  t是一个列表，从t中随机选一项：random.choice(t)，如：

  import random
  list=[1,2,3]
  B= random.choice(list)
  print(B)
  

  1

常用内置函数

sum

sum([……])

sum({1,2,3})

sum({2:4,1:5,3:9}) #键值key的和

sum({2:4,1:5,3:9}.values())

1. sum()的参数是一个list
2. sum()的参数也可以是集合、元组或字典

💡 注意：对字典用sum，他计算的是key，而不是value。计算键的值的时候，使用字典对象的属性values()。

sum(1,2,3)#写法不正确！！
print(sum({2:4,1:5,3:9}.items()))#写法不正确！！

#sum()的参数是一个list，例如：
print(sum([1,2,3]))

#sum()的参数也可以是集合、元组或字典，例如：
print(sum({1,2,3}))
print(sum({2:4,1:5,3:9}))#键值key的和
print(sum({2:4,1:5,3:9}.values()))

6
6
6
18

• sum()的其他用法：

  range(1,10）左闭右开！！！！！10取不到
  

  a = range(1,11)
  b = range(1,10)
  c =  sum([item for item in a if item in b])
  print(c)
  

  45

  相当于1-9累加和

zip, 要list一下

Zip(t,s)返回t和s的一个相互匹配的列表。

>>> t='abc'
>>> s=[1,2,3]
>>> z=zip(t,s)
<zip object at 0x04104A08>
>>> list(z)
[('a', 1), ('b', 2), ('c', 3)]

若长度不够，以最短的为主。

>>> zip('abcd','123')
<zip object at 0x041049E0>
>>> list(zip('abcd','123'))
[('a', '1'), ('b', '2'), ('c', '3')]

注:类似于元组里说的解包。

一般认为*是一个unzip的过程，它的运行机制是这样的：
在运行zip(*xyz)之前，xyz的值是：[(1, 4, 7), (2, 5, 8), (3, 6, 9)],那么zip(*xyz) 等价于 zip((1, 4, 7), (2, 5, 8), (3, 6, 9)),所以运行结果是：[(1, 2, 3), (4, 5, 6), (7, 8, 9)]。

x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
xyz = zip(x, y, z)
u = zip(*xyz)
print(list(u))

结果
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]

[x]生成一个列表的列表，它只有一个元素x
*3生成一个列表的列表，它有3个元素，[x, x, x]
zip( [x] * 3)的意思就明确了，zip(x, x, x)

x = [1, 2, 3]
a = zip( [x]*3 )
print(list(a))

r = zip(* [x] * 3)
print(list(r))

[([1, 2, 3],), ([1, 2, 3],), ([1, 2, 3],)]
[(1, 1, 1), (2, 2, 2), (3, 3, 3)]

dict和zip可以组合使用生成字典：dict(zip)

name=["awdwd","qeqde","qewdqd","sefwfew"]
tel=[123,234,345,456]
zip(name,tel)

print(dict(zip(name,tel)))

{‘awdwd’: 123, ‘qeqde’: 234, ‘qewdqd’: 345, ‘sefwfew’: 456}

enumerate：枚举

返回t的index和元素对，t可以是字符串、列表、元组、字典等，若是字典返回的是键名。

t={'first':'j','second':'h','third':'abc'}
for i,k in enumerate(t):
   print(i,k)

0 first
1 second
2 third

t=((2,2),("f",9),(8,'7'))
for i,k in enumerate(t):
   print(i,k)

0 (2, 2)
1 (‘f’, 9)
2 (8, ‘7’)

t=['first',2,3,'4','awdee',['q2w',43]]
for i,k in enumerate(t):
   print(i,k)

0 first
1 2
2 3
3 4
4 awdee
5 [‘q2w’, 43]

max/min

与sum类似

max()和min()的参数，可以是列表、元组、集合、字典，甚至可以是range。
字典默认对key计算，若需要对value计算，则需要使用values()方法。

• max(a) \ min(a)：返回最大/小的键

  a={1:2,3:4,5:6}
  max(a)   
  
  a={1:2,30000:4,900:'0'}
  max(a)
  
  B={'a':2,'b':4,'c':6}
  min(B)
  

  5
  3000
  ’a’

• min(a.values()) \ max(a.values())：返回最大/小的值

  B={'a':2,'b':4,'c':6}
  min(B.values())
  
  a={1:2,3:4,5:6}
  max(a.values())
  

  2
  6

eval

输入的时候，将字符串转为其他格式

eval()函数将字符串str当成有效的表达式来求值并返回计算结果。
其他用法，可以把list,tuple,dict和string相互转化。见下例子。

>>>a = "[[1,2], [3,4], [5,6], [7,8], [9,0]]" #注意a是字符串
>>>b = eval(a)
>>>b
[[1, 2], [3, 4], [5, 6], [7, 8], [9, 0]]
>>>type(b)
List
>>>c = "{1: 'a', 2: 'b'}" #注意c是字符串
>>>d = eval(c)
>>>d
 {1: 'a', 2: 'b'}
>>>type(d)
dict

常用内置函数—>判断函数：返回true或false

in

常用于字符串、列表、元组、字典、集合中，用来判断一个字符串或者一个元素是否属字符串或者列表等，还有对应的not in()。

>>>a={'a':2,'b':4,'c':6}
>>>'a' in a
True
>>>'c' not in a
False

startswith()、endswith()：

做文本处理的时候用来判断字符串开始和结束的位置。基本格式：

S.startswith(prefix[, start[, end]])和S.endswith(suffix[, start[, end]])

>>>"fish".startswith('fi')
True
>>>"fish".startswith('fi',1)  #此处的1表示从索引位置1开始
False
>>> "fish".endswith('sh')
True
>>> "fish".endswith('sh',3)
False

💡 Python的这两个函数有个特别的地方——它的prefix和suffix参数不仅可以是字符串，还都可以是一个元组。只要其中一个成立，就返回True，也就是一种“或”的关系。比如：

if filename.endswith(('.gif', '.jpg', '.tiff')):
    print("%s是一个图片文件" %filename)
也可以写成：
if filename.endswith(".gif") or filename.endswith(".jpg") or filename.endswith(".tiff"):
    print("%s是一个图片文件"%filename)

isalnum()

检测字符串是否仅由字母和数字组成，若其间夹杂有空格，标点符号或者其他的字符则都返回False。

>>>str = "this2009"
>>>print(str.isalnum())
True
>>>str = "this is string example....wow!!!"
>>>print(str.isalnum())
False
>>>str1 = "hello"
>>>print(str1.isalnum())
True

isalpha()

检测字符串是否只由字母组成，如果字符串至少有一个字符并且所有字符都是字母则返回 True,否则返回 False。

>>>str = "this"
>>>print(str.isalpha())
True
>>>str = "this is string example....wow!!!"
>>>print(str.isalpha())
False

isdigit()

检查字符串是否只包含数字(全由数字组成)，如果字符串中的所有字符都是数字，并至少有一个字符则返回true，否则返回false。

>>>str = "123456"
>>>print(str.isdigit())
True
>>>str = "this is string example....wow!!!"
>>>print(str.isdigit())
False

文件的读写

引用一下别人的文章：
https://blog.csdn.net/weixin_41261833/article/details/104462907?ops_request_misc=%7B%22request%5Fid%22%3A%22163377950316780357260513%22%2C%22scm%22%3A%2220140713.130102334…%22%7D&request_id=163377950316780357260513&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_alltop_positive~default-1-104462907.pc_search_result_control_group&utm_term=python读取文件&spm=1018.2226.3001.4187

常见错误

Python是面向对象语言，所以程序抛出的异常也是类。

异 常	描 述
NameError	尝试访问一个没有申明的变量
SyntaxError	语法错误
ZeroDivisionError	除数为0
IndexError	索引超出序列范围
KeyError	请求一个不存在的字典关键字
IOError	输入输出错误（比如要读的文件不存在）
AttributeError	尝试访问未知的对象属性
IndentationError	冒号换行后没有缩进
ValueError	传给函数的参数类型不正确，比如给int()函数传入字符串形

上面的错误是因为try行后有冒号，下一行x没有缩进，包括后面的几行都应该缩。

while 1:
    try:
    x = int(input('No.1：'))
    y = int(input('No.2：'))
    
    r= x/y
    print(r)
    except (Exception) as e:
        print(e)
        print('again')
    else:
        break
 
  File "<ipython-input-15-6f26b9b9c36e>", line 3
    x = int(input('No.1：'))
    ^
IndentationError: expected an indented block

try

在python中，try/except语句主要是用于处理程序正常执行过程中出现的一些异常情况，如语法错误、数据除零错误、从未定义的变量上取值等；而try/finally语句则主要用于监控错误的环节。尽管try/except和try/finally的作用不同，但是在编程实践中通常可以把它们组合在一起使用try/except/else/finally的形式来实现稳定性和灵活性更好的设计。

python中try/except/else/finally语句的完整格式如下所示。

try:
     Normal execution block
except A:
     Exception A handle
except B:
     Exception B handle
except:
     Other exception handle
else: #可无，必有except x或except时存在，仅在try后无异常执行
     if no exception, get here 
finally:   #此语句务必放在最后，并且也是必须执行的语句
     print("finally")

需要注意的是：

1. 在上面所示的完整语句中try/except/else/finally所出现的顺序必须是try–>except x–>except–>else–>finally，即所有的except必须在else和finally之前，else（如果 有的话）必须在finally之前，而except x必须在except之前。否则会出现语法错误。
2. 对于上面所展示的try/except完整格式而言，else和finally都是可选的，而不是必须的，但是如果存在的话else必须在finally之前，finally（如果存在的话）必须在整个语句的最后位置。
3. 在上面的完整语句中，else语句的存在必须以except x或者except语句为前提，如果在没有except语句的try block中使用else语句会引发语法错误。也就是说else不能与try/finally配合使用。
4. except的使用要非常小心，慎用。

assert

assert是断言的关键字。执行该语句的时候，先判断表达式expression，如果表达式为真，则什么都不做；如果表达式为假，则抛出异常。

>>> assert len('love') == len('like')
>>> assert len('love u') == len('like')
Traceback (most recent call last):
  File "<pyshell#15>", line 1, in <module>
    assert len('love u') == len('like')
AssertionError

如果assert后面的表达式为真，则什么都不做，如果为假，就会抛出AssertionErro异常。

raise

当程序出现错误，python会自动引发异常，也可以通过raise显示地引发异常。一旦执行了raise语句，raise后面的语句将不能执行。

try:
    s = None
    if s is None:
        print("s 是空对象")
        raise NameError  #如果NameError异常，后面代码都将不执行
    print(len(s))
except TypeError:
    print("空对象没有长度")

s 是空对象
Traceback (most recent call last):

File “”, line 5, in
raise NameError #如果NameError异常，后面代码都将不执行

NameError

模块与包

计算机由于浮点数的运算问题，会导致上面的结果有差异。但是我们引入一个math后，计算结果就正常了。

例子：
>>> a=[1.23e+18, 1, -1.23e+18]
>>> sum(a)
0.0

>>> import math
>>> math.fsum(a)
1.0

模块=文件

就是你的Python文件

取别名

1.import math #导入math模块
2.import math as m #导入math模块并取个别名为m
3.from math import exp as e #导入math库中exp函数并取别名为e

要想使用import导入的模块中的函数，则必须以“模块名.函数名”的形式调用函数；
而from是将模块中某个函数而不是整个模块导入，所以使用from导入模块中的某个函数，则可以直接使用函数名调用，不必在前面加上模块名称。
如上例可以用如下方式调用：

>>> import math as m  #给math模块取个别名m，使用时用m替代math
>>> a=[1.23e+18, 1, -1.23e+18]
>>> m.fsum(a)
1.0
 
>>> from math import fsum #这里仅导入了math模块中的fsum函数
>>> a=[1.23e+18, 1, -1.23e+18]
>>> fsum(a)
1.0

可以在from中使用“*”通配符，表示导入模块中的所有函数，但一般不这么用。如下：

>>> from math import sqrt  	#仅导入了sqrt函数
>>> sqrt(4)
2.0
>>> cos(4)           		#仅导入了sqrt函数，所以cos函数不能用
Traceback (most recent call last):
  File "<pyshell#13>", line 1, in <module>
    cos(4)
NameError: name 'cos' is not defined

>>> from math import *   	#将math中的所有函数全部导入
>>> sqrt(4)
2.0
>>> cos(4)
-0.6536436208636119

包=文件夹

python的包要有_init_.py便于区分普通文件夹

import math
math.fsum(a)
import math as m
m.fsum(a)

from math import fsum
fsum(a)
from math import fsum as f
f(a)

from math import *
fsum(a)

import语句使用以下几种方式导入包中的模块:

import yubg.Primitive.fill
#导入模块yubg.Primitive.fill,只能以全名访问模块属性,
#例如yubg.Primitive.fill.floodfill(img,x,y,color)
from yubg.Primitive import fill
#导入模块fill ,只能以 fill.属性名这种方式访问模块属性,
#例如 fill.floodfill(img,x,y,color)
from yubg.Primitive.fill import floodfill
#导入fill,并将函数floodfill放入当前名称空间,直接访问被导入的属性，
#例如floodfill(img,x,y,color)

data、datatime和calendar模块

• 说明

  在 Python 中，与时间处理有关的模块包括：time，datetime，以及 calendar等。

必要说明：

1. 虽然这个模块总是可用，但并非所有的功能都适用于各个平台。

该模块中定义的大部分函数是调用 C 平台上的同名函数实现，所以各个平台上实现可能略有不同。

必要说明：

2. 一些术语和约定的解释：

• 时间戳（timestamp）的方式：通常来说，时间戳表示的是从 1970 年 1 月 1 日 00:00:00
  开始按秒计算的偏移量（time.gmtime(0)），此模块中的函数无法处理 1970
  纪元年以前的日期和时间或太遥远的未来（处理极限取决于 C 函数库，对于 32 位系统来说，是 2038 年）

• UTC（Coordinated Universal Time，世界协调时）也叫格林威治天文时间，是世界标准时间。在中国为 UTC+8

• DST（Daylight Saving Time）即夏令时的意思

• time模块

  >>> import time
  >>> t1=time.time() #时间戳
  >>> t1
  1633944417.8016157
  >>>
  >>> t2=time.ctime() #时间字符串
  >>> t2
  'Mon Oct 11 17:26:57 2021'
  >>>
  >>> t3=time.asctime() #时间字符串
  >>> t3
  'Mon Oct 11 17:26:57 2021'
  >>>
  >>> t4=time.localtime() #时间元组
  >>> t4
  time.struct_time(tm_year=2021, tm_mon=10, tm_mday=11, tm_hour=17, tm_min=26, tm_sec=57, tm_wday=0, tm_yday=284, tm_isdst=0)
  >>> time.ctime(t1) #将时间戳转换成字符串
  'Mon Oct 11 17:26:57 2021'
  >>> time.asctime(t4)
  'Mon Oct 11 17:26:57 2021'
  
  >>> time.strftime('%Y/%m/%d %H:%M:%S')
  '2021/10/11 17:30:36'
  >>> time.strptime('2021/10/11 17:30:36','%Y/%m/%d %H:%M:%S')
  time.struct_time(tm_year=2021, tm_mon=10, tm_mday=11, tm_hour=17, tm_min=30, tm_sec=36, tm_wday=0, tm_yday=284, tm_isdst=-1)
  
  

  说明：
  tm_year	年
  tm_mon	月
  tm_mday	日
  tm_hour	时
  tm_min	分
  tm_sec	秒
  tm_wday	一周中的第几天
  tm_yday	一年中的第几天
  tm_isdst	夏令时（-1代表夏令时）

• datetime模块

  说明：
  timedelta()的参数还可以是hours=5，或者是weeks=5、minutes=5、seconds=5，但没有years和months，因为年和月的时间不定，如月份有30天和31天。

  >>> import datetime
  >>> datetime.date.today()              		#返回当前日期
  datetime.date(2016, 6, 25)
   
  >>> datetime.date(2016, 4, 10)
  datetime.date(2016, 4, 10)
   
  >>> datetime.date.today().ctime()      	#返回当前日期时间
  'Sat Jun 25 00:00:00 2016'
   
  >>> datetime.date.today().timetuple()  	#返回当前的时间元组格式
  time.struct_time(tm_year=2016, tm_mon=6, tm_mday=25, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=177, tm_isdst=-1)
  
  >>> print(datetime.datetime.now()) 		#返回当前正常的日期时间
  2016-06-25 13:56:47.281702
   
  >>> t = datetime.datetime.now()   		#取当前日期时间
  >>> m = t + datetime.timedelta(5) 		#在t时刻上增加5天（默认是天）
  >>> m
  datetime.datetime(2016, 6, 30, 13, 56, 53, 998939)
   
  >>> m = t + datetime.timedelta(weeks=5)
  >>> print(m)
  2016-07-30 13:56:53.998939
  

• calendar模块

  >>> import calendar
  >>> m = calendar.month(2019,10)		#返回某年某月的日历
  >>> print(m)
        October 2019
  Mo Tu We Th Fr Sa Su
         1   2   3  4   5   6
    7   8   9 10 11 12 13
  14 15 16 17 18 19 20
  21 22 23 24 25 26 27
  28 29 30 31
  
  >>> n = calendar.calendar(2019,w=2,l=1,c=6) #见后注
  >>> print(n)
  

  注：n = calendar.calendar(2019,w=2,l=1,c=6) #返回某年的年历，三个月一行，间隔为距离c，每日宽度间隔为w字符，每行长度为21w+18+2c，l是每星期行间距。

Urllib模块

当我们想把网上的东西down下来时，也就是大家常说的爬虫，这里就要用到urllib模块，具体如下：

>>> import urllib.request
>>> ur = urllib.request.urlopen("http://www.i-nuc.com")
>>> content = ur.read()
>>> mystr = content.decode("utf8")
>>> ur.close()
>>> print(mystr)
  
<!DOCTYPE html>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>首页 - iNUC, 我爱中北</title>
…
>>>

需要注意：
urllib.request.urlopen(“http://www.i-nuc.com”)
这里参数是网址，“http://”不能少，否则会报错！

类

类的定义

定义类（class）的语法：

不用手动定义类型

class NameClass(object):
def fname(self, name):
self.name = name

第一行是class 后面紧接类的名称，最后带上“：”。类的名称首字母最好是大写。
第二行开始是类的方法，和函数非常相似，但是与普通函数不同的是，它的内部有一个“self”参数，它的作用是对对象自身的引用。

💡 self表示自身对象，有点像this

• 举例

      def __init__(self, name, score): #初始化类，相当于c++的构造函数。（_init_叫魔法方法）
          self.name = name
          self.score = score
      def print_score(self):
          print('{0},{1}'.format(self.name,self.score))
  #实例化 bart = Student('Bart Simpson', 59) lisa = Student('Lisa Simpson', 87) bart.print_score() lisa.print_score() 
  

  Bart Simpson,59
  Lisa Simpson,87

创建类时，可以定义一个特定的方法，名为__init__(),只要创建这个类的一个实例就会运行这个方法。可以向__init__()方法传递参数，这样创建对象时就可以把属性设置为我们希望的值，init()这个方法会在创建对象时完成初始化。

python没有保护成员，只有私有公有

class Peo:
	def __init__(self,name,age,sex):
        self.Name = name #self.__Name = name(加__变私有)
        self.Age = age
        self.Sex = sex
	def speak(self):
		print("my name：" + self.Name) 

#实例化
zhangsan = Peo("zhangsan", 59,"man")
print(zhangsan.Age)
zhangsan.speak()

Self

python如何给self赋值以及为何不需要给它赋值？

假如有一个MyClass类和其一个实例MyObj。当调用这个对象的方法MyObj.method(arg1,arg2) 的时候，这会由Python自动转为MyClass.method(MyObj, arg1, arg2)——这就是self的原理了。
这也意味着如果有一个不需要参数的方法，但是我们还得给这个方法定义一个self参数。比较下面类和函数的区别。

类：
#coding = utf-8
#创建实例类Test
class Test(object):    
def add(self,a,b):
'''
打印输出a+b的值,注意类方法需要添加self
'''
print(a+b)
def display(self):
'''
打印输出字符串,注意类方法需要添加self，尽管不需要参数
'''
print('hell, here is a Class test.')
 
test = Test()    #创建一个类实例test
test.add(1,3)    #调用方法
test.display()

函数：
def addTwo(a,b):   #不需要加self参数
print(a+b)
 
addTwo(1,2)

__init__(),

创建类时，可以定义一个特定的方法，名为__init__(),只要创建这个类的一个实例就会运行这个方法。可以向__init__()方法传递参数，这样创建对象时就可以把属性设置为我们希望的值，init()这个方法会在创建对象时完成初始化。

>>> class peo:
	def __init__(self,name,age,sex):
	self.Name = name
	self.Age = age
	self.Sex = sex
	def speak(self):
		print("my name：" + self.Name)

实例化这个类的对象时：

>>> zhangsan=peo("zhangsan",24,'man')
>>> print(zhangsan.Age)
24
>>> print(zhangsan.Name)
zhangsan
>>> print(zhangsan.Sex)
Man
>> zhangsan.speak()
my name：zhangsan

• 类与类的联系
• 依赖关系
• 关联关系
• 组合关系
• 聚合关系
• 继承关系