python复习

1.Python编程

1.1python简介

Python 是一种简单易学，功能强大的编程语言，它有高效率的高层数据结构，简单而有效地实现面向对象编程。Python 简洁的语法和对动态输入的支持，再加上解释性语言的本质，使得它在大多数平台上的许多领域都是一个理想的脚本语言，特别适用于快速的应用程序开发。

Python与Java, C, C++并列为全球4大最流行语言. 从C到C++,到Java再到Python, 细节越来越少, 让开发者把更多的精力放在”做什么”, 而不是”怎么做”。

1.2python的两种运行方式

1.2.1解释运行

·新建py文件，直接运行

%%writerfile print_str.py
print('Hello World')

!python3 print_str.py

1.2.2交互运行

·ipython/notebook

1.3 Python标识符

1.3.1 合法标识符

·数字、下划线、字母构成
·避开关键字
·不能用数字开头

1.3.2 好的命名习惯让开发更有效率

·变量，函数或者方法
·常量
·类：BankAccount #驼峰命名

1.3.3名字和对象之间的建立引用与解除引用

我们可以用 = 建立名字与对象之间的关联 用del名字来解除这种关联

1.4python标准操作符与优先级

操作符的优先级关系如下：

第1名 - 函数调用、寻址、下标
第2名 - 幂运算 **
第3名 - 翻转运算符 ~
第4名 - 正负号
第5名 - *、/、%
第6名 - +、-

#赋值
 c = 100

#多重赋值
a = b = 100

#多元赋值
a,b,c = 100,200,300

#交换赋值
a,b = b,a

#拓展知识

#unpack解包
l1 = [1,2,3,4,5,6]
a , b , *c , d = l1 
print(a , b , c , d)
#输出结果：1 2 [3,4,5] 6

#*号收集
a,*b,c = l1 
print(a,b,c)
#输出结果: 1 [2,3,4,5] 6

#*号展开，针对序列
l1 = [1,2,3,4]
s1 = 'Hello,World'
[*l1 , *s1]
#输出结果:[1,2,3,4,'H','e','l','l',',','W','o','r','l','d']

#*号针对字典
d1 = {'name1':'aabbcc', 'name2':'bbccdd,*'}
[*d1],{**d1,'date':'2020-12-12'}
#输出结果：(['name1','name2'],{'name1':'aabbcc' , 'name2':'bbccdd,*','date':'2020-12-12'})

1.5python基本数据类型和数据结构

1.5.1 基本数据类型：数值型

整型/浮点型/科学计数法/复数

1.5.2 基本数据类型：字符串型

索引与切片（左闭右开）

1.5.3 基本数据类型：布尔型

True / False

1.5.4 python数据结构

1.5.4.1 列表list(任意元素：数值型 字符串 list都可以放进去）

①增：
append:把要加的东西作为一个元素追加
extend:把要加的东西作为一个列表追加

②删：
pop():删除list中最尾部的元素,且有返回值
remove('a'): 删除列表中某个值的第一个匹配项

③改：
l1[0] = a 将l1中第一个元素改成a

④查：
位置访问，切片。

⑤拼接与切分：
join/split

⑥列表排序
sort():直接改变list
sorted():对列表排序，并且以返回值的形式返回排序后的结果，原始的list没有改变。

1.5.4.2 元组tuple（只读列表）

1.5.4.3 集合set（无序，不重复）

1.5.4.4 字典dic：

可变容器模型，且可存储任意类型对象。字典的每个键值 key=>value 对用冒号 : 分割，每个键值对之间用逗号 , 分割，整个字典包括在花括号 {} 中
①.keys：取出所有的键
②.values:取出所有的值
③dict['key'] 取出key所对应的value
④dict.get('key',123) #如果没有key 则返回123
⑤in判断是否有某个key
⑥遍历：
for key in dict:
----print(key,dict['key'])

注意：字典是一种键值对的数据结构，本身是无序的，如果要顺序，可以使用OrderedDict

form collections import OrederedDict #根据主键的顺序进行排序

1.6声明Statement与Expression表达式

1.6.1 声明statement

a = 'python学习' #statement通常为赋值语句

1.6.2expression表达式（通常有返回结果）

#由值 变量和运算符共同组成的整体我们称其为表达式，通常有值表达式，变量表达式，计算表达式，字符串表达式
b , b+100 , a+'hello' , __builtins__

1.6.3 exec执行声明语句，eval执行表达式

exec('a = 5')
a
b = 3 
eval('a+b+5')
#输出结果 13

1.7 判断与循环

判断循环:if /if else/ if elif
逻辑循环:for / while / break continue
列表推导式：从一个列表中生成一个新的列表，简化了循环的写法

l1= [x+1 for x in range(30) if x%3==0] #新的list中的元素，来源于从0-29这个list中所有整除3的元素+1
l1
#输出结果：[1, 4, 7, 10, 13, 16, 19, 22, 25, 28]

可迭代对象与迭代器：
如果我有一个很大的列表，都存到我的内存里，会占很大的空间，有没有可以优化的东西：有！可以有一个类似指针的东西指着他，然后每次滑动一个位置 滑动一个位置 滑动一个位置

image.png

如果我有l1 我可以通过iter将其放入迭代器 然后用next一个一个取

l1=[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
l2=iter(l1)
l2.__next__()

#可迭代对象Iterable：可以被for循环的对象统称为可迭代对象Iterable,list,str,dict这些都是可迭代类型
#迭代器Iterator：可以被next调用的迭代器。
#next(l1) #TypeError: 'list' object is not an iterator

#使用iter将一来个可迭代对象变为迭代器
l1=iter(l1)
next(l1),next(l1)


#生成器Generator：首先是一个迭代器，然后其内容是按需生成
#列表是一次性生成，缺点是当内容过大时会占用大量内容，那能不能用到多少生成多少呢？
#Python里一边循环一边计算(惰性计算)的迭代器称为生成器（Generator）

#1.直接从列表表达式生成
g1= (x**2 for x in range(30) if x%2==0)
type(g1)
next(g1),next(g1),next(g1),next(g1),g1.__next__(),g1.__next__()

#2.函数生成，与yield关键字
def g2_func(n):
    for i in range(n):
        yield i**2
    
g2=g2_func(7)
next(g2),next(g2),g2.__next__(),g2.__next__(),g2.__next__(),g2.__next__()

#yield from/子迭代器，后面直接是可迭代对象。
def yield_from_iter(iter_object):
    yield from iter_object
    
y1=yield_from_iter('China')
y1.__next__(),next(y1)
#返回结果
(0, 3)

(0, 4, 16, 36, 64, 100)
(0, 1, 4, 9, 16, 25)
('C', 'h')

1.8异常处理

1.8.1异常/exception对象

异常同样也是Python对象，表示一个在程序执行过程中发生了影响正常运行时而产生的一个事件(产生一个traceback.)

image.png

捕获并处理异常对象

捕捉异常对象要使用try/except,或try/else,try/finally 语句
try语句用来检测try语句块中的错误，从而让except语句捕获异常信息并处理

try:
    a=never_named_value
    #a=2
    print(int(a))
except Exception as e:
    print(e)
else:
    print('Everything is fine')

#try-finally 无法是否捕获了异常，都会执行finally后的语句
x = 5
#y = 2
y = 0
try:
    result = x / y
except ZeroDivisionError:
    print("division by zero!")
else:
    print("result is", result)
finally:
    print("executing finally clause")

1.9 函数

函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。 函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

你可以定义一个由自己想要功能的函数，以下是简单的规则：

函数代码块以 def 关键词开头，后接函数标识符名称和圆括号()。
任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

1.9.1函数定义

def fib(n):
        a , b = 1,1
        for i in  range(n):
            print(a , end = " ")
            a , b = b , a+b
        print()
fib(5)
###输出结果 1 1 2 3  5 8  13 21 34 55

1.9.2默认函数

def printinfo(arg1, *vartuple):
   "打印任何传入的参数"
   print("输出:")
   print(arg1)
   print(vartuple)
   return
 
# 调用printinfo 函数
printinfo(10)
printinfo(70, 60, 50)
#输出结果
#输出:
姓名: 隔壁老王
年龄: 50
姓名: 隔壁老王
年龄: 35

1.9.3变长参数函数

def printinfo(arg1, *vartuple):
   "打印任何传入的参数"
   print("输出:")
   print(arg1)
   print(vartuple)
   return
 
# 调用printinfo 函数
printinfo(10)
printinfo(70, 60, 50)
#输出结果:
输出:
10
()
输出:
70
(60, 50)

1.9.4匿名函数

# python 使用 lambda 来创建匿名函数。lambda [arg1,arg2,.....argn]:expression
sum = lambda arg1, arg2: arg1 + arg2;
 
# 调用sum函数
print("相加后的值为:", sum( 10, 20 ))
print("相加后的值为:", sum( 20, 30 ))
#输出结果：
相加后的值为: 30
相加后的值为: 50

1.9.5一些内置高阶函数

1.9.5.1filter :过滤(判断，只返回True的结果）

filter()函数接收一个函数 f 和一个list，这个函数 f 的作用是对每个元素进行判断，返回 True或 False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

1.9.5.2map:映射

map()是 Python 内置的高阶函数，它接收一个函数 f 和一个 list，并通过把函数 f 依次作用在 list 的每个元素上，得到一个新的 list 并返回。

1.9.5.3reduce：类似贪吃蛇

reduce()函数也是Python内置的一个高阶函数。reduce()函数接收的参数和 map()类似，一个函数 f，一个list，但行为和 map()不同，reduce()传入的函数 f 必须接收两个参数，reduce()对list的每个元素反复调用函数f，并返回最终结果值。

1.10文件和目录的操作

1.10.1 读文件

# 要以读文件的模式打开一个文件对象，使用Python内置的open()
f = open('print_str.py , 'r')
f.read()
f.close()

#逐行读取
with open('print_str.py , 'r') as f 
        for line in f.readlines():
                print(line)

1.10.2 写文件

with open( 'writer_text.txt' , 'w') as f
              f.write('Hello, world!\n')
              f.write('new line')

1.10.3目录操作

# 需要用到os内置模块
import os
# 列举当前绝对路径
os.path.abspath('.')
# 新建文件夹
os.mkdir('../../tmp/testdir')
# 文件重命名
os.rename('../../tmp/test.txt', '../../tmp/test2.txt')
# 列出当前路径下的所有文件夹
[x for x in os.listdir('.') if os.path.isdir(x)]
# 列出当前路径下的所有python脚本文件
[x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py']

1.11面向对象

1.11.1面向对象编程

-类class与对象object

--对属于同一类事物的抽象叫类class
---比如汽车，蛋糕，猫。

--某类事物中的一个具体的实例叫对象Object

---比如小区门口的那辆黑色的奥迪汽车，好利来里的那种奶油芝士蛋糕，隔壁小花家的那只小花猫。
-类与对象的关系
--类定义封装了数据与方法，类就是对象的模板，可以批量生产出许多的对象。
--类(class)的变量是所有对象共享使用, 只有一个拷贝, 所有对象修改, 都可以被其他对象所见;
--对象(object)的变量由类的每个对象所拥有, 每个对象都包含自己的一份拷贝, 不会影响其他对象;

# 类的设计与创建
# 使用 class 语句来创建一个新类，class 之后为类的名称并以冒号结尾，类的主体由类成员，方法，数据属性组成

class Employee:
    "所有员工的基类"
    empCount = 0

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1

    def displayCount(self):
        print("总共雇员数量 %d" % Employee.empCount)

    def displayEmployee(self):
        print("姓名: ", self.name,  ", 工资: ", self.salary)
        
# empCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。
# 第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法
# self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

# 创建对象
"创建 Employee 类的第一个对象"
emp1 = Employee("张三", 2000)
"创建 Employee 类的第二个对象"
emp2 = Employee("李四", 5000)

# 调用成员函数
emp1.displayEmployee()
emp2.displayEmployee()
print("总共雇员数%d" % Employee.empCount)
输出结果：
姓名:  张三 , 工资:  2000
姓名:  李四 , 工资:  5000
总共雇员数2

#__dict__ : 类的属性（包含一个字典，由类的数据属性组成）
#__doc__ :类的文档字符串
#__name__: 类名
#__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）
#__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）
print("Employee.__doc__:", Employee.__doc__)
print("Employee.__name__:", Employee.__name__)
print("Employee.__module__:", Employee.__module__)
print("Employee.__bases__:", Employee.__bases__)
print("Employee.__dict__:", Employee.__dict__)