Python学习笔记

第一章 计算机基础

1.1硬件

处理器,内存条,硬盘,显卡,网卡,主板...

1.2操作系统

Windows: xp/7/8/10

Linux: Ubuntu/CentOS/RedHat

Unix: MacOS

1.3解释器或编译器

解释器:Python/PHP/Ruby.按行处理,报错行之前都会运行,与计算机交流频繁.

编译器:Java/C/C++.把代码编译成文件,报错则不能编译,与计算机交流少.

1.4软件

人操作软件,软件是人与操作系统之间的桥梁,通过操作系统指挥硬件完成功能.

1.5进制

二进制:逢2进1.0,1,10,11...

八进制:逢8进1.0,1...6,7,10,...

十进制:逢10进1.0,1...,9,10,11...

十六进制:逢16进1.0,1,2...9,a,b,c,d,e,f,10...

第二章 Python入门

2.1环境安装

python官网下载,安装之后添加环境变量.

2.2编码

ASCII:英文数字和符号,8bit,1byte.

Unicode:万国码,可容纳所有语言,32bit,4byte,浪费资源.

UTF-8:简化万国码,英文8bit,欧洲16bit,中文24bit.

GBK:国标码,16bit,2byte.

GB2312,UTF-16.

2.3变量

变量命名规范:1.由数字,字幕,下划线组成.

2.不能由数字开头.

3.不能是关键字.

2.4python2和3的区别

• 字符串类型不同
  • 2:str型转换为unicode型 3:byte型转换为str型
• 默认解释器编码
  • 2:ASCII 3:UTF-8
• 输入
  • 2:raw_input() 3:input()
• 输出:
  • 2:print("") 3:print ""
• int
  • 2:int,有范围,超出则为long长整型 3:int,无范围
• 除法
  • 2:没有小数,需要加一行代码 3:有小数
• range和xrang
  • 2:range为立即创建列表,占内存.xrange为边循环边创建,省内存. 3:range即为2中的xrange.
• 模块和包
  • 2:导入文件夹需要__init__文件 3:不需要
• 字典返回值
  • 2:列表 3:迭代器
• map/filter返回值
  • 2:列表 3:迭代器

2.5

2.6注释

单行注释:

# 注释内容

多行注释:

'''
注释内容
'''

2.7if语句

if 条件1:
    代码块1
elif 条件2:
    代码块2
...
else:
    代码块n

2.8while语句

while 条件:
    代码块1
else:
    代码块2

当条件不符合时执行else,符合条件时有break则退出while循环,continue则结束本次循环执行下次循环.

2.9运算符

算数运算:
+ / - / * / /
+= / -= / *= / /=

逻辑运算:
not > and > or
in / not in

...

'''

第三章 数据类型

3.1整型int

无独有方法

py2中有int有范围,超出自动转为long长整型,py3中只有int

整除py2中无小数,可加一行代码实现

3.2布尔值bool

只有True和False.无独有方法.

0,'',[],{},(,),set()都可转化为False,其他为True.

3.3字符串str ''

3.4列表list []

3.5字典dict {}

{key:value}

3.6元组tuple (,)

无独有方法,不可改变

3.7集合set() {,}

无重复内容

3.8公共功能

3.9嵌套

小九九乘法表:

for a in range(1,10):
    for b in range(1,a+1):
        if a == b:
            print('%s*%s=%s' % (b, a, a * b))
        else:
            print('%s*%s=%s' % (b,a,a*b),end=' ')

第四章 文件操作

4.1文件基本操作

f = open('filename',mode='模式',encoding='编码类型')
f.write()	#写
f.read()	#读
f.flush()	#刷新
f.close()	#关闭文件

4.2打开模式

r 只读 只能读取(常用)

w 只写 写入前清空文件内容(常用)

a 追加 追加内容到文件末尾(常用)

r+ 读写 / w+ 写读 / a+ 追加读写

rb 读取二进制 / wb 写入二进制 / ab 追加二进制

r+b 读写二进制 / w+b 写读二进制 / a+b 追加读写二进制

4.3操作

read() 将文件全部读取到内存

read(1) mode=r读取一个字符,mode=rb读取一个字节

write() 写入

seek() 调整光标位置

tell() 获取当前光标位置

flush() 强制将内存中的内容写入到文件

close() 关闭文件,with打开不用关闭

4.4文件的修改

with open('file1',mode='r',encoding='utf-8') as f1,
	open('file2',mode='w',encoding='utf-8') as f2:
#小文件
	data = f1.read()
    new_data = data.replace('内容1','内容2')
    f2.write(new_data)
#大文件
	for line in f1:
        new_line = line.replace('内容1','内容2')
        f2.write(new_line)

第五章 函数

5.1三元运算(三目运算)

v = 内容1 if 条件 else 内容2

符合条件输出内容1,否则输出内容2

5.2函数式编程

把N行代码定义成一个变量,后面直接调用变量即可.

可读性强,可重用性强.

5.3基本结构

三种方法:

def func1(a1,a2):
    pass 

def func2(a1,a2=None):
    pass 

def func3(*args,**kwargs):
    pass 

调用时位置参数在前 , 关键字参数在后.

5.4参数

• 不限数量,不限数据类型

• 位置传参,按位置挨个代入

  def func(a1,a2):
      代码块
  func(1,2)	#a1=1,a2=2

• 关键字传参

  • 位置传参在前,关键字在后

  def func(a,b,c):
      代码块
  func(1,2,c=3)	#c=3是关键字参数

• 默认参数

  def func(a,b=2,c=3):
      代码块
  func(1)	#b默认等于2,c=3,传入其他值则修改.

• 万能参数

  • *args接收多个位置参数
  • **kwargs接收多个关键字参数

  def func(*args,**kwargs):
      print(args,kwargs)

def 函数名(形式参数):
	代码块
函数名(实际参数)

5.5返回值

def 函数名():	#定义
	代码块
   	return x	#返回值x,不填默认None
print(函数名())	#调用函数,输出x/None

5.6作用域

• 在python中,整个py文件是全局作用域,函数内部是局部作用域.

  a = 1
  def s1():	
      x1 = 666
      print(x1)	#3.输出666
      print(a)	#4.局部没有a则去父级找,输出1
      print(b)	#5.局部没有a则去父级找,输出2
  
  b = 2
  print(a)	#1.输出1
  s1()		#2.调用s1()
  a = 88888	#6.a被重新赋值
  def s2():
      print(a,b)	#8.输出88888,2
      s1()	#9.调用s1,输出666,88888,2
  
  s2()		#7.调用s2()

• 一个函数有一个作用域.

  def func():
      x = 9
      print(x)	#2.输出9
  func()		#1.调用func()
  print(x)	#3.全局没有x报错

• 优先在局部查找,找不到去父级找, 找不到再去父级找,直到全局,全局没有则报错.

  x = 10			#1.全局变量x=10
  def func():
      x = 8		#3.局部变量x=8
      print(x)	#4.输出8
      def x1():	
          print(x)	#6.x1()局部没有x去父级找,x=8输出8
      x1()		#5.调用x1()
      x = 9		#7.x重新赋值为9
      x1()		#8.调用x1()	9.输出9
      x = 10		#10.x重新赋值为10
      print(x)	#11.输出10
  func()			#2.调用func()

• 只能子级去父级找,不能为父级的变量赋值.能修改可变数据类型.

  name = 'oldboy'
  def func():
      name = 'alex'	#2.在自己作用域再创建一个这样的值。
      print(name)		#3.输出alex
  func()			#1.调用func()
  print(name)		#4.输出oldboy

  name = [1,2,43]
  def func():
      name.append(999)	#2.name是列表,可变
      print(name)		#3.输出[1,2,43,999]
  func()				#1.调用func()
  print(name)			#4.输出[1,2,43,999]

• global使用全局变量.

  name = ["老男孩",'alex']
  def func():
      global name		#2.调用全局变量name
      name = '我'		#3.name被重新赋值
  func()				#1.调用func()
  print(name)			#4.输出我

  name = "老男孩"
  def func():
      name = 'alex'		#2.局部name=alex
      def inner():
          global name		#4.调用全局变量name
          name = 999		#5.name被重新赋值
      inner()				#3.调用inner()
      print(name)			#6.输出局部变量name:alex
  func()					#1.调用func()
  print(name)				#7.输出999

• nonlocal使用父级变量.

  name = "老男孩"
  def func():
      name = 'alex'		#2.局部变量
      def inner():
          nonlocal name	#4.找到上一级的name
          name = 999		#5.将父级name重新赋值
      inner()				#3.调用inner()
      print(name)			#6.输出999
  func()					#1.调用func()
  print(name)				#7.输出老男孩

• 全局变量必须全部大写.

5.7函数高级

• 函数名作变量,内存地址赋值

  def func():
  	print(123)
  v1 = func	# func内存地址给v1
  func()
  v1()		#v1()也执行func()

• 数据类型中包含函数地址

  def func():
      print(123)			# 4.输出123,return默认返回None
      
  func_list = [func, func, func]	# 3.列表中三项都指向func
  # func_list[0]()
  # func_list[1]()
  # func_list[2]()
  for item in func_list:
      v = item()			# 1.func_list中的值赋给v
      print(v)			# 2.输出

  def func():
      print(123)
  
  def bar():
      print(666)
  
  info = {'k1': func, 'k2': bar}
  
  info['k1']()			# 1.调用func,输出123
  info['k2']()			# 2.调用bar,输出666

• 函数作为参数传递

  def func(arg):
      print(arg)		# 2.输出1
      
  func(1)				# 1.调用func
  func([1,2,3,4])		# 3.调用func,输出[1,2,3,4]
  
  def show():
      return 999
  func(show)		# 4.调用func,传入show,输出show内存地址

  def func(arg):
      v1 = arg()		# 2.v1 = show(),调用show
      print(v1)		# 4.输出show()的返回值None
      
  def show():
      print(666)		# 3.输出666
      
  func(show)			# 1.调用func,传入show

  def func(arg):
      v1 = arg()			# 2.v1 = show(),输出666
      print(v1)			# 3.输出show()的返回值None
      
  def show():
      print(666)
      
  result = func(show)		# 1.func传入show	4.res=None
  print(result)			# 5.输出func的返回值None

• 调用多个函数

  def func():
      print('花费查询')
  def bar():
      print('语音沟通')
  def base():
      print('xxx')
  def show():
      print('xxx')
  def test():
      print('xxx')
  info = {
      'f1': func,
      'f2': bar,
      'f3':base,
      'f4':show,
      'f5':test
  }
  choice = input('请选择要选择功能：')
  function_name = info.get(choice)	# 根据输入的键选择info中的值
  if function_name:				# 存在则执行,不存在为None
      function_name()				# 执行:键()
  else:
      print('输入错误')

• 函数作返回值

  def func():
      print(123)
  
  def bar():
      return func
  
  v = bar()			# 调用bar,v=func
  
  v()					# v()=func(),输出123

  name = 'oldboy'
  def func():
      print(name)
      
  def bar():
      return func
  
  v = bar()			#调用bar,v=func
  
  v()					# v()=func(),输出oldboy.

  def bar():
      def inner():
          print(123)
      return inner
  v = bar()			#调用bar,v=inner
  v()					#inner()输出123

  name = 'oldboy'
  def bar():
      name = 'alex'
      def inner():
          print(name)
      return inner
  v = bar()			#调用bar,v=inner
  v()					#inner()输出alex

  name = 'oldboy'
  def bar(name):
      def inner():
          print(name)
      return inner
  v1 = bar('alex') 	# 调用bar,v1=inner
  v2 = bar('eric') 	# 调用bar,v2=inner
  v1()	# inner()输出alex
  v2()	# inner()输出eric

5.8lambda表达式

• 用于表示简单的函数。

  def func(a1,a2):
      return a1 + 100 
  
  func = lambda a1,a2: a1+100		#接收输入的值为a1和a2,:后面为return返回值

5.9内置函数

• 输入输出:

  print() input()

• 数学运算:

  sum() max() min() abs() float() divmod()

• 强制转换:

  int() str() list() tuple() dict() set() bool()

• 其他:

  len() open() range() id() type()

• 进制转换:

  bin() oct() hex() int()

• 编码相关:

  chr()，将十进制数字转换成 unicode 编码中的对应字符串.

  ord()，根据字符在unicode编码中找到其对应的十进制.

  应用于生成随机验证码.

• 高级内置函数

  • map , 映射,循环让每个元素执行函数，将每个函数执行的结果保存到新的列表中，并返回。

    v1 = [11,22,33,44]
    result = map(lambda x:x+100,v1)	# 第一个参数为执行的函数,第二个参数为可迭代元素.
    print(list(result)) # [111,122,133,144]

  • filter , 按条件筛选.

    v1 = [11,22,33,'asd',44,'xf']
    
    # 一般做法
    def func(x):
        if type(x) == int:
            return True
        return False
    result = filter(func,v1)
    print(list(result))		# [11,22,33,44]
    
    # 简化做法
    result = filter(lambda x: True if type(x) == int else False ,v1)
    print(list(result))
    
    # 极简做法
    result = filter(lambda x: type(x) == int ,v1)
    print(list(result))

  • reduce , 对参数序列中元素进行累积.

    import functools
    v1 = ['wo','hao','e']
    
    def func(x,y):
        return x+y
    result = functools.reduce(func,v1) 
    print(result)
    
    result = functools.reduce(lambda x,y:x+y,v1)
    print(result)

5.10闭包

• 为函数创建一块区域并为其维护自己数据，以后执行时方便调用。

  def func(name):
      def inner():
          print(name)
  	return inner 
  
  v1 = func('alex')	# 调用func,v1=func
  v1()				# func()输出alex
  v2 = func('eric')	# 调用func,v2=func
  v2()				# func()输出eric

5.11自定义函数

• 函数式编程：增加代码的可读性和重用性。

• 生成器:

  def func():
      yield 1
      yield 2
      yield 3
      
  v = func()  # 生成器
  # 循环v时或v.__next__() 时输出1,2,3。

• 列表推导式

  v1 = [i for i in range(10)] # 立即循环创建所有元素。
  print(v1)

• 生成器推导式

  v2 = (i for i in range(10)) # 创建了一个生成器，内部循环为执行。

第六章 模块

6.1md5加密字符串

• 普通加密

  import hashlib		# 引入模块
  
  def get_md5(data):
      obj = hashlib.md5()		# 简单加密,易被破解
      obj.update(data.encode('utf-8'))
      result = obj.hexdigest()
      return result
  
  val = get_md5('123')	# md5加密'123'
  print(val)

• 加盐 , 高级加密

  import hashlib
  
  def get_md5(data):
      obj = hashlib.md5("resdy54436jgfdsjdxff123ad".encode('utf-8'))
      obj.update(data.encode('utf-8'))
      result = obj.hexdigest()
      return result
  
  val = get_md5('123')
  print(val)

• 应用于用户注册登录

  import hashlib
  USER_LIST = []		# 注册用户列表
  def get_md5(data):	# 加密函数
      obj = hashlib.md5("12:;idy54436jgfdsjdxff123ad".encode('utf-8'))
      obj.update(data.encode('utf-8'))
      result = obj.hexdigest()
      return result
  
  
  def register():		# 注册函数
      print('**************用户注册**************')
      while True:
          user = input('请输入用户名:')
          if user == 'N':
              return
          pwd = input('请输入密码:')
          temp = {'username':user,'password':get_md5(pwd)}
          USER_LIST.append(temp)
  
  def login():		# 登录函数
      print('**************用户登陆**************')
      user = input('请输入用户名:')
      pwd = input('请输入密码:')
  
      for item in USER_LIST:
          if item['username'] == user and item['password'] == get_md5(pwd):
              return True
  
  
  register()
  result = login()
  if result:
      print('登陆成功')
  else:
      print('登陆失败')

• 密码隐藏

  pycharm不管用,cmd中可用.

  import getpass
  
  pwd = getpass.getpass('请输入密码：')
  if pwd == '123':
      print('输入正确')

6.2装饰器

• 定义:在不改变原函数内部代码的基础上，在函数执行之前和之后自动执行某个功能。

def func(arg):
    def inner():
        arg()
    return inner

def f1():
    print(123)

v1 = func(f1)		# 调用func,f1给arg,返回inner给v1
v1()			# 调用inner,f1()输出123

def func(arg):
    def inner():
        return arg()
    return inner

def f1():
    print(123)
    return 666

v1 = func(f1)	# 调用func,f1给arg,返回inner给v1
result = v1() # 执行inner,arg()=f1()输出123,返回666给inner的return,返回给result.
print(result) # 666

def func(arg):
    def inner():
        v = arg()
        return v 
    return inner 

# 第一步：执行func函数并将下面的函数参数传递，相当于：func(index)
# 第二步：将func的返回值重新赋值给下面的函数名。 index = func(index)
@func 
def index():
    print(123)
    return 666

print(index)

# 计算函数执行时间
import time

def wrapper(func):
    def inner():
        start_time = time.time()
        v = func()
        end_time = time.time()
        print(end_time-start_time)
        return v
    return inner

@wrapper
def func1():
    time.sleep(2)
    print(123)
@wrapper
def func2():
    time.sleep(1)
    print(123)

def func3():
    time.sleep(1.5)
    print(123)

func1()

• 目的 : 在不改变原函数的基础上,再函数执行前后自定义功能.

• 编写装饰器和应用

  def x(func):
      def y():
          # 前
          ret = func()
          # 后
          return ret 
     	return y 
  
  # 装饰器的应用
  @x
  def index():
      return 10
  
  @x
  def manage():
      pass
  
  # 执行函数，自动触发装饰器了
  v = index()
  print(v)

• 装饰器格式

  def 外层函数(参数): 
      def 内层函数(*args,**kwargs):
          return 参数(*args,**kwargs)
      return 内层函数

• 装饰器应用格式

  @外层函数
  def index():
      pass
  
  index()

• 带参数的装饰器

  def x(counter): 
      print('x函数')
      def wrapper(func):
          print('wrapper函数')
          def inner(*args,**kwargs):
              if counter:
                  return 123
              return func(*args,**kwargs)
          return inner
      return wrapper
  
  @x(True)	# 处理第一种情况
  def fun990():
      pass
  
  @x(False)	# 处理第二种情况
  def func10():
      pass

• 无敌装饰器

  def x1(func):
      def inner(*args,**kwargs):			# 无敌,接收任意参数
          return func(*args,**kwargs)
      return inner 

6.2推导式

• 列表推导式 , 目的:方便生成一个列表.

  v1 = [i for i in 可迭代对象 ]
  v2 = [i for i in 可迭代对象 if 条件 ]

• 集合推导式

  v1 = { i for i in 'alex' }

• 字典推导式

  v1 = { 'k'+str(i):i for i in range(10) }

6.3import和from x import y

• import

  • import 模块1 模块1.函数()
  • import 模块1.模块2.模块3 模块1.模块2.模块3.函数()

• from xx import xxx

  • from 模块.模块 import 函数 函数()
  • from 模块.模块 import 函数 as f f()
  • from 模块.模块 import * 函数1() 函数2()
  • from 模块 import 模块 模块.函数()
  • from 模块 import 模块 as m m.函数()

• 特殊情况

  • import 文件夹 加载 __ init__ .py
  • from 文件 import *

• 模块和要执行的py文件在同一目录且需要模块中的很多功能时,推荐用import 模块.

• 其他情况推荐:

  1.from 模块 import 模块 模块.函数()

  2.from 模块.模块 import 函数 函数()

6.4内置模块

6.4.1sys

• sys.path 默认Python导入模块时,会按照sys.path中的路径挨个查找.

  import sys
  sys.path.append('D:\\')
  import oldboy

• sys.getrefcount , 获取一个值的应用计数

  a = [11,22,33]	# 1
  b = a	# 2 
  print(sys.getrefcount(a)) # 3

• sys.getrecursionlimit , 可修改python默认支持的递归数量

• sys.stdout.write 相当于print,最后加上长度

• sys.argv 获取用户执行脚本时传入的参数 , 组成列表 , 第一项为脚本本身

• sys.exit() 任意位置终止程序

6.4.2os

• os.rename(a,b) a重命名为b

• os.mkdir 创建目录

• os.makedirs 创建目录和子目录

• os.stat(文件路径) 查看文件大小

• os.path.exists(path) ， 如果path存在，返回True；如果path不存在，返回False

• os.stat('filename').st_size ， 获取文件大小

• os.path.abspath() ， 获取一个文件的绝对路径

  path = 'filename' # D:\code\s21day14\filemname
  
  import os
  v1 = os.path.abspath(path)
  print(v1)

• os.path.dirname ，获取路径的上级目录

  import os
  v = r"D:\code\s21day14\filename"
  
  print(os.path.dirname(v))

• os.path.join ，路径的拼接

  import os
  path = "D:\code\s21day14" # user/index/inx/fasd/
  v = 'n.txt'
  
  result = os.path.join(path,v)
  print(result)
  result = os.path.join(path,'n1','n2','n3')
  print(result)

• os.listdir ， 查看一个目录下所有的文件【第一层】

  import os
  
  result = os.listdir(r'D:\code\s21day14')
  for path in result:
      print(path)

• os.walk ， 查看一个目录下所有的文件【所有层】

import os

result = os.walk(r'D:\code\s21day14')
for a,b,c in result:
    # a,正在查看的目录 b,此目录下的文件夹  c,此目录下的文件
    for item in c:
        path = os.path.join(a,item)
        print(path)

• 补充转义

v1 = r"D:\code\s21day14\n1.mp4"  (推荐)
print(v1)

v2 = "D:\\code\\s21day14\\n1.mp4"
print(v2)

6.4.3json

• 特殊的字符串 , 只有:int / str / list / dict

• 最外层必须是列表或字典,如果包含字符串,必须是双引号"".

• 序列化:将Python的值转换为json格式的字符串.

• 反序列化:将json格式的字符串转换成Python的数据类型.

• 优点:所有语言通用

  缺点:只能序列化基本的数据类型.

• json字典或列表中如有中文,序列化时想保留中文显示:

  v = {'k1':'alex','k2':'李杰'}
  
  import json
  val = json.dumps(v,ensure_ascii=False)
  print(val)

• dumps

  import json
  
  v = {'k1':'alex','k2':'李杰'}
  f = open('x.txt',mode='w',encoding='utf-8')
  val = json.dump(v,f,ensure_ascii=False)
  print(val)
  f.close()

• loads

  import json
  
  f = open('x.txt',mode='r',encoding='utf-8')
  data = json.load(f)
  f.close()
  print(data,type(data))

6.4.4time

UTC / GMT : 世界时间

本地时间 : 本地时区的时间(东八区)

• time.time() 时间戳,1970-1-1 00:00

• time.sleep(10) 运行等待秒数

• time.timezone 距0经度时区时间差 , 秒

6.4.5hashlib

• md5加密

6.4.6random

• random.randint() 随机数字

6.4.7getpass

• getpass.getpass() 密码不显示

6.4.8shutil

import shutil

# 删除目录
# shutil.rmtree('test')

# 目录重命名
# shutil.move('test','ttt')

# 压缩文件
# shutil.make_archive('zzh','zip','D:\code\s21day16\lizhong')
#   			压缩成的文件名		格式 		把该目录压缩

# 解压文件
# shutil.unpack_archive('zzh.zip',extract_dir=r'D:\code\xxxxxx\xxxx',format='zip')
# 					要解压的文件		解压到的路径				压缩类型

6.4.9copy

• copy.copy() 浅拷贝
• copy.deepcopy() 深拷贝

6.4.10pickle

• 优点:Python中所有的东西都能被序列化(除socket对象)

  缺点:序列化的内容只有Python认识.

6.4.11datetime

import time
from datetime import datetime,timezone,timedelta

# ######################## 获取datetime格式时间 ##############################
"""
v1 = datetime.now() # 当前本地时间
print(v1)
tz = timezone(timedelta(hours=7)) # 当前东7区时间
v2 = datetime.now(tz)
print(v2)
v3 = datetime.utcnow() # 当前UTC时间
print(v3)
"""

# ######################## 把datetime格式转换成字符串 ##############################
# v1 = datetime.now()
# print(v1,type(v1))
# val = v1.strftime("%Y-%m-%d %H:%M:%S")
# print(val)

# ######################## 字符串转成datetime ##############################
# v1 = datetime.strptime('2011-11-11','%Y-%m-%d')
# print(v1,type(v1))

# ######################## datetime时间的加减 ##############################
# v1 = datetime.strptime('2011-11-11','%Y-%m-%d')
# v2 = v1 - timedelta(days=140)
# date = v2.strftime('%Y-%m-%d')
# print(date)

# ######################## 时间戳和datetime关系 ##############################
# ctime = time.time()
# print(ctime)
# v1 = datetime.fromtimestamp(ctime)
# print(v1)

# v1 = datetime.now()
# val = v1.timestamp()
# print(val)

6.4.12异常处理

报错时使用

try:
    内容
except Exception:
    print('操作异常')

6.5第三方模块

6.5.1安装

1.pip包管理工具: pip install 模块

2.源码安装:

• 下载源码包 : 压缩文件.
• 解压压缩包
• 打开cmd,进入python安装目录下的lib\site-packages
• 执行python3 setup.py build
• 执行python3 setup.py install

3.自定义

• py文件
• 文件夹: 要创建 __ init__.py 文件

6.5.2调用模块

• import
  • import 模块1 模块1.函数()
  • import 模块1.模块2.模块3 模块1.模块2.模块3.函数()
• from xx import xxx
  • from 模块.模块 import 函数 函数()
  • from 模块.模块 import 函数 as f f()
  • from 模块.模块 import * 函数1() 函数2()
  • from 模块 import 模块 模块.函数()
  • from 模块 import 模块 as m m.函数()
• 特殊情况
  • import 文件夹 加载 __ init__ .py
  • from 文件 import *

6.6自定义模块

• 可以把一个py文件或一个文件夹(包)当做一个模块,以方便于以后其他py文件的调用.

• py2:文件夹中必须有__ init __.py文件

  py3:不需要__ init __.py

  推荐加上该文件.

第七章 面向对象

1.基本格式

# ###### 定义类 ###### 
class 类名:
    def 方法名(self,name):
        print(name)
        return 123
    def 方法名(self,name):
        print(name)
        return 123
    def 方法名(self,name):
        print(name)
        return 123
# ###### 调用类中的方法 ###### 
# 1.创建该类的对象
obj = 类名()
# 2.通过对象调用方法
result = obj.方法名('alex')
print(result)

• 代码从上到下执行

  class Foo:
      print('你')
      x = 1
      def func(sef):
          pass
      
      class Meta:
          print('好')
          y = 123
          def show(self):
              pass
  # 输出 你	好

2.对象的作用

• 存储一些值，方便以后自己使用。

class File:
    def read(self):
        with open(self.xxxxx, mode='r', encoding='utf-8') as f:
            data = f.read()
        return data

    def write(self, content):
        with open(self.xxxxx, mode='a', encoding='utf-8') as f:
            f.write(content)

# # 实例化了一个File类的对象
obj1 = File()
# # 在对象中写了一个xxxxx = 'test.log'
obj1.xxxxx = "test.log"
# # 通过对象调用类中的read方法，read方法中的self就是obj。
# # obj1.read()
obj1.write('alex')


# 实例化了一个File类的对象
obj2 = File()
# 在对象中写了一个xxxxx = 'test.log'
obj2.xxxxx = "info.txt"
# 通过对象调用类中的read方法，read方法中的self就是obj。
# obj2.read()
obj2.write('alex')

class Person:
    def show(self):
        temp = "我是%s,年龄：%s,性别：%s " %(self.name,self.age,self.gender,)
        print(temp)
        
p1 = Person()
p1.name = '李邵奇'
p1.age = 19
p1.gender = '男'
p1.show()

p2 = Person()
p2.name = '利奇航'
p2.age = 19
p2.gender = '男'
p2.show()

class Person:
    def __init__(self,n,a,g): # 初始化方法（构造方法），给对象的内部做初始化。
        self.name = n
        self.age = a
        self.gender = g

    def show(self):
        temp = "我是%s,年龄：%s,性别：%s " % (self.name, self.age, self.gender,)
        print(temp)

# 类() 实例化对象，自动执行此类中的 __init__方法。
p1 = Person('李兆琪',19,'男')
p1.show()

p2 = Person('利奇航',19,'男')
p2.show()

总结：将数据封装到对象，方便使用。

3.归类和公共值

• 如果写代码时,函数比较多,比较乱:

  1.可以将函数归类,并放到同一个类中

  2.函数如果有一个反复使用的公共值,则可以放到对象中.(__ init__(self,xxx))

class File:
    def __init__(self,path):
        self.file_path = path
    def read(self):
        print(self.file_path)
    def write(self,content):
        print(self.file_path)
    def delete(self):
        print(self.file_path)
    def update(self):
        print(self.file_path)

p1 = File('log.txt')
p1.read()

p2 = File('xxxxxx.txt')
p2.read()

# 循环让用户输入：用户名/密码/邮箱。 输入完成后再进行数据打印。
# 1.
class Person:
    def __init__(self,user,pwd,email):
        self.username = user
        self.password = pwd
        self.email = email
	
USER_LIST = [对象(用户/密码/邮箱),对象(用户/密码/邮箱),对象(用户/密码/邮箱)]
while True:
    user = input('请输入用户名：')
    pwd = input('请输入密码：')
    email = input('请输入邮箱：')
    p = Person(user,pwd,email)
    USER_LIST.append(p)

for item in USER_LIST:
    temp = "我的名字：%s,密码：%s,邮箱%s" %(item.username,item.password,item.email,)
    print(temp)
    
# 2.
class Person:
    def __init__(self,user,pwd,email):
        self.username = user
        self.password = pwd
        self.email = email
        
    def info(self):
        return "我的名字：%s,密码：%s,邮箱%s" %(item.username,item.password,item.email,)
    
USER_LIST = [对象(用户/密码/邮箱),对象(用户/密码/邮箱),对象(用户/密码/邮箱)]
while True:
    user = input('请输入用户名：')
    pwd = input('请输入密码：')
    email = input('请输入邮箱：')
    p = Person(user,pwd,email)
    USER_LIST.append(p)

for item in USER_LIST:
    msg = item.info()
    print(msg)

4.游戏开发

class Police:
    def __init__(self,name):
        self.name = name
        self.hp = 10000
    
    def tax(self):
        msg = "%s收了个税。" %(self.name,)
        print(msg)

lsq = Police('李邵奇')
zzh = Police('渣渣会')
tyg = Police('堂有光')


class Bandit:
    def __init__(self,nickname)
		self.nickname = nickname 
		self.hp = 1000
	
    def murder(self,name):
        msg = "%s去谋杀了%s" %(self.nickname, name,)


lcj = Bandit('二蛋')
lp = Bandit('二狗')
zsd = Bandit('狗蛋')

# 1. 二狗去谋杀渣渣会，二狗生命值-100; 渣渣会生命值减5000
lp.murder(zzh.name)
lp.hp = lp.hp - 100
zzh.hp = zzh.hp - 5000
# ... 

class Police:
	def __init__(self,name)
		self.name = name
         self.hp = 10000
    def dao(self,other):
        msg = "%s个了%s一刀。" %(self.name,other.nickname)
        self.hp = self.hp - 10
        other.hp = other.hp - 50
        print(msg)
    def qiang(self):
        msg = "%s去战了个斗。" %(self.name,)
	def quan(self,other):
        msg = "%s个了%s一全。" %(self.name,other.nickname)
        self.hp = self.hp - 2
        other.hp = other.hp - 10
        print(msg)


class Bandit:
    def __init__(self,nickname)
		self.nickname = nickname
		self.hp = 1000
    def qiang(self,other):
        msg = "%s个了%s一全。" %(self.nickname,other.name)
        self.hp -= 20
        other.hp -= 500


lcj = Bandit('二蛋')
lsq = Police('李邵奇')
lsq.dao(lcj)
lsq.quan(lcj)
lcj.qiang(lsq)

5.继承

# 父类(基类)
class Base:
    def f1(self):
        pass
# 子类（派生类）
class Foo(Base):
    def f2(self):
        pass

# 创建了一个字类的对象
obj = Foo()
# 执行对象.方法时，优先在自己的类中找，如果没有就是父类中找。
obj.f2()
obj.f1()

# 创建了一个父类的对象
obj = Base()
obj.f1()

# 示例三
class Base:
    def f1(self):
        print('base.f1')
        
class Foo(Base):
    def f2(self):
        self.f1()
        print('foo.f2')
	def f1(self):
        print('foo.f1')
        
obj = Foo()
obj.f2()	# foo.f1	foo.f2

# 示例四
class Base:
    def f1(self):
        self.f2()
        print('base.f1')
	def f2(self):
        print('base.f2')
class Foo(Base):
    def f2(self):
        print('foo.f2')
        
obj = Foo()
obj.f1()	# foo.f2	base.f1

# 示例五
class TCPServer:
    pass
class ThreadingMixIn:
    pass
class ThreadingTCPServer(ThreadingMixIn, TCPServer): 
    pass

# 示例六
class BaseServer:
    def serve_forever(self, poll_interval=0.5):
        self._handle_request_noblock()
	def _handle_request_noblock(self):
        self.process_request(request, client_address)
        
	def process_request(self, request, client_address):
        pass
    
class TCPServer(BaseServer):
    pass

class ThreadingMixIn:
    def process_request(self, request, client_address):
        pass
    
class ThreadingTCPServer(ThreadingMixIn, TCPServer): 
    pass

obj = ThreadingTCPServer()
obj.serve_forever()		# 类可以有多个基类,从左往右挨个找.

注意事项：

• self 到底是谁.
• self 是哪个类创建的，就从此类开始找，自己没有就找父类(基类)。

6.多态和鸭子模型

# Python
def func(arg):
    v = arg[-1] # arg.append(9)
    print(v)

# java
def func(str arg):
    v = arg[-1]
    print(v)

面试题：什么是鸭子模型。

对于一个函数而言，Python对于参数的类型不会限制，那么传入参数时就可以是各种类型，在函数中如果有例如：arg.send方法，那么就是对于传入类型的一个限制（类型必须有send方法）。
这就是鸭子模型，类似于上述的函数我们认为只要能呱呱叫的就是鸭子（只有有send方法，就是我们要想的类型）

7.使用面向对象的情况

• 函数(业务功能)比较多,可以使用面向对象来进行归类.
• 想要做数据封装(创建字典存储数据时,面向对象).
• 游戏示例:创建一些角色并且根据角色需要再创建人物.

8.迭代器

• 对某种(str / list / tuple / dict / set类创建的对象) 可迭代对象中的元素进行逐一获取,表象:具有__ next__方法且每次调用都获取可迭代对象中的元素.

• 列表转换成迭代器

  v1 = iter([11,22,33,44])
  v1 = [11,22,33,44].__iter__()
  # iter()和.__iter__()都是转换为迭代器

• 迭代器获取每个值需反复调用

  v1 = [11,22,33,44]
  
  # 列表转换成迭代器
  v2 = iter(v1)
  result1 = v2.__next__()
  print(result1)			# 11
  result2 = v2.__next__()
  print(result2)			# 22
  result3 = v2.__next__()
  print(result3)			# 33
  result4 = v2.__next__()
  print(result4)			# 44
  result5 = v2.__next__()
  print(result5)			# 超出范围报错StopIteration
  """
  # v1 = "alex"
  # v2 = iter(v1)
  # while True:
  #     try:
  #         val = v2.__next__()
  #         print(val)
  #     except Exception as e:
  #         break
  
  try:
  	内容
  except Exception:
  	break
  报错结束进程
  """

• 报错表示迭代完毕.

• 判断一个对象是否是迭代器:dir(对象)查看内部是否有__ next__()方法.

• for循环内部会把可迭代对象转化为迭代器,反复执行__ next__(),取完不报错

9.可迭代对象

• dir(对象)查看内部是否具有__ iter__()方法,且返回一个迭代器.

• 表象：可以被for循环对象就可以称为是可迭代对象.

  class Foo:
      def __iter__(self):
          return iter([1,2,3,4])
  
  obj = Foo()
  
  class Foo:
      def __iter__(self):
          yield 1
          yield 2
          yield 3
  
  obj = Foo()

10.生成器

• 如果函数中存在yield,该函数就是生成器函数,调用该生成器函数会返回生成器,生成器被for循环时,内部代码才会执行,每次返回yield的值,下次循环从yield下一行开始.

# 生成器函数(内部包含yield)
def func():
    print('F1')
    yield 1
    print('F2')
    yield 2
    print('F3')
    yield 100
    print('F4')
# 函数内部代码不执行,返回一个生成器
v1 = func()
# 生成器可以被for循环，一旦开始循环那么函数内部代码就会开始执行。
for i in v1:
    print(i)

def func():
    count = 1
    while True:
        yield count		# 循环一次返回yield停止,下次循环从下一行开始.
        count += 1

val = func()		# 获取生成器

for item in val:	# 开始循环生成器
    print(item)		# 1,2,3...

def func():
    count = 1
    while True:
        yield count
        count += 1
        if count == 100:		# 符合条件即停止函数.
            return

val = func()
for item in val:				# 1,2...99
    print(item)

• 读取redis文件

  def func():
      """
      分批去读取文件中的内容，将文件的内容返回给调用者。
      :return:
      """
      cursor = 0
      while True:
          f = open('db', 'r', encoding='utf-8')# 通过网络连接上redis
          # 代指   redis[0:10]
          f.seek(cursor)
          data_list =[]
          for i in range(10):
              line = f.readline()
              if not line:
                  return
              data_list.append(line)
          cursor = f.tell()
          f.close()  # 关闭与redis的连接
  
          for row in data_list:
              yield row
  
  for item in func():
      print(item)

11.类成员

11.1实例变量

class Foo:
    def __init__(self,name):
        self.name = name
        
    def info(self):
        pass

obj1 = Foo('alex')
obj2 = Foo('eric')

11.2类变量

• 定义 : 写在类的下一级和方法同一级.

  class Foo:
      city = '北京'
      
      def __init__(self,name):
          self.name = name

• 访问:

  • 类.类变量名称
  • 对象 : 类变量名称

• 面试题

  class Base:
      x = 1
  
  obj = Base()
  
  
  print(obj.x) # 先去对象中找，没有再去类中找。	1
  obj.y = 123  # 在对象中添加了一个y=123的变量。
  print(obj.y)	# 123
  obj.x = 123
  print(obj.x)	# 123
  print(Base.x)	# 1

class Parent:
    x = 1
    
class Child1(Parent):
    pass

class Child2(Parent):
    pass

print(Parent.x,Child1.x,Child2.x) # 1 1 1
Child1.x = 2
print(Parent.x,Child1.x,Child2.x) # 1 2 1
Child2.x = 3
print(Parent.x,Child1.x,Child2.x) # 1 2 3

总结：找变量优先找自己，自己没有找 类 或 基类；修改或赋值只能在自己的内部设置。

11.3方法（绑定方法/普通方法）

• 定义：至少有一个self参数

• 执行：先创建对象，由对象.方法()。

  class Foo:
      def func(self,a,b):
          print(a,b)
  
  obj = Foo()
  obj.func(1,2)
  # ###########################
  class Foo:
      def __init__(self):
          self.name = 123
  
      def func(self, a, b):
          print(self.name, a, b)
  
  obj = Foo()
  obj.func(1, 2)

11.4静态方法

• 定义：
  • @staticmethod装饰器
  • 参数无限制
• 执行：
  • 类.静态方法名 ()
  • 对象.静态方法() (不推荐)

class Foo:
    def __init__(self):
        self.name = 123

    def func(self, a, b):
        print(self.name, a, b)

    @staticmethod
    def f1():
        print(123)

obj = Foo()
obj.func(1, 2)

Foo.f1()
obj.f1() # 不推荐

11.5类方法

• 定义：
  • @classmethod装饰器
  • 至少有cls参数，当前类。
• 执行：
  • 类.类方法()
  • 对象.类方法() （不推荐）

class Foo:
    def __init__(self):
        self.name = 123

    def func(self, a, b):
        print(self.name, a, b)

    @staticmethod
    def f1():
        print(123)

    @classmethod
    def f2(cls,a,b):
        print('cls是当前类',cls)
        print(a,b)

obj = Foo()
obj.func(1, 2)

Foo.f1()	# 123
Foo.f2(1,2)	# 类名称, 1, 2

• 面试题：

# 问题： @classmethod和@staticmethod的区别？
"""
一个是类方法一个静态方法。
定义：
	类方法：用@classmethod做装饰器且至少有一个cls参数。
	静态方法：用staticmethod做装饰器且参数无限制。
调用：
	类.方法直接调用。
	对象.方法也可以调用。
"""

11.6属性

• 定义：
  • @property装饰器
  • 只有一个self参数
• 执行：
  • 对象.方法 不用加括号。

class Foo:

    @property
    def func(self):
        print(123)
        return 666

obj = Foo()
result = obj.func	# 123
print(result)	# 666

• 属性的应用 , 分页

# 属性的应用

class Page:
    def __init__(self, total_count, current_page, per_page_count=10):
        self.total_count = total_count
        self.per_page_count = per_page_count
        self.current_page = current_page

    @property
    def start_index(self):
        return (self.current_page - 1) * self.per_page_count

    @property
    def end_index(self):
        return self.current_page * self.per_page_count

# 创建一个321项的列表
USER_LIST = []
for i in range(321):
    USER_LIST.append('alex-%s' % (i,))

# 请实现分页展示：
current_page = int(input('请输入要查看的页码：'))
p = Page(321, current_page)
data_list = USER_LIST[p.start_index:p.end_index]
for item in data_list:
    print(item)

12.成员修饰符

• 公有，所有地方都能访问到。
• 私有，只有自己可以访问到。

class Foo:
    def __init__(self, name):
        self.__name = name

    def func(self):
        print(self.__name)


obj = Foo('alex')
# print(obj.__name)
obj.func()

class Foo:
    __x = 1

    @staticmethod
    def func():
        print(Foo.__x)


# print(Foo.__x)
Foo.func()

class Foo:

    def __fun(self):
        print('msg')

    def show(self):
        self.__fun()

obj = Foo()
# obj.__fun()
obj.show()

13.补充

class Foo:
    def __init__(self,num):
        self.num = num


cls_list = []
for i in range(10):
    cls_list.append(Foo)
    
for i in range(len(cls_list)):
    obj = cls_list[i](i)
    print(obj.num)

class Foo:
    def __init__(self,num):
        self.num = num

B = Foo
obj = B('alex')

class Foo:
	def f1(self):
        print('f1')

    def f2(self):
        print('f2')

obj = Foo()

v = [ obj.f1,obj.f2 ]
for item in v:
    item()

class Foo:
    def f1(self):
        print('f1')
    
    def f2(self):
        print('f2')
        
	def f3(self):
        v = [self.f1 , self.f2 ]
        for item in v:
            item()
            
obj = Foo()
obj.f3()

class Account:

    def login(self):
        pass

    def register(self):
        pass

    def run(self):
        info = {'1':self.register, '2':self.login }
        choice = input('请选择:')
        method = info.get(choice)
        method()

class Foo:
    pass

class Foo(object):
    pass

# 在python3中这俩的写法是一样，因为所有的类默认都会继承object类，全部都是新式类。

# 如果在python2中这样定义，则称其为：经典类
class Foo:
    pass 
# 如果在python2中这样定义，则称其为：新式类
class Foo(object):
    pass 

class Base(object):
    pass
class Bar(Base):
    pass

• 强制访问私有成员

class Foo:
    def __init__(self,name):
        self.__x = name


obj = Foo('alex')

print(obj._Foo__x) # 强制访问私有实例变量

14.嵌套

• 函数：参数可以是任意类型。
• 字典：对象和类都可以做字典的key和value
• 继承的查找关系

class StarkConfig(object):
    pass

class AdminSite(object):
    def __init__(self):
        self.data_list = []
        
    def register(self,arg):
        self.data_list.append(arg)
        
site = AdminSite()
obj = StarkConfig()
site.register(obj)

class StarkConfig(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age

class AdminSite(object):
    def __init__(self):
        self.data_list = []
        self.sk = None

    def set_sk(self,arg):
        self.sk = arg

site = AdminSite() # data_list = []  sk = StarkConfig
site.set_sk(StarkConfig)
site.sk('alex',19)

class StackConfig(object):
    pass

class Foo(object):
    pass

class Base(object):
    pass

class AdminSite(object):
    def __init__(self):
        self._register = {}

    def registry(self,key,arg):
        self._register[key] = arg

site = AdminSite()
site.registry(1,StackConfig)
site.registry(2,StackConfig)
site.registry(3,StackConfig)
site.registry(4,Foo)
site.registry(5,Base)

for k,v in site._register.items():
    print(k,v() )