python知识复习

前记：python版本为 Python 3.7.6 编辑器为 jupyter notebook 和 pycharm 2020.2.2 不是零基础

Python的基础语法

程序结构

缩进分层：python语言的特点就是用缩进分层来写模块，缩进最好采用空格的形式，每一层向右缩进4个空格

if True:
    print("牧童骑黄牛")
    print("歌声振林樾") # 严格执行缩进
else:
    print("意欲扑鸣蝉")
    print("忽然闭口立")

牧童骑黄牛
歌声振林樾

换行问题：Python语言中的换行问题主要包括以下几种：
1.换行符：DOS/Windows操作系统，换行字符为ASCII CRLF

print("牧童骑换牛\n歌声振林樾")

牧童骑换牛
歌声振林樾

2.程序代码超过一行：可以在每行的结尾添加反斜杠
每个行末的反斜杠之后不添加注释文字
以小括号(),中括号[],大括号{}包含的语句，不必使用反斜杠就可以直接分行

if 1990 < year < 2100 and 1 <= month <= 12 \
and 1 <= day <= 31 and 0 <= hour < 24:
    print("输入数据正确")

month_names = ['Jau','feb',
              'Maa','Apr']

3.将数行表达式写成一行：只需要在每一行的结尾添加分号即可

x = 100;y = 50
print(x)
print(y)

100
50

代码注释：单行注释(以 # 好开头) 和 多行注释(以3个单引号(’’’)或者多引号(""")开头)

Python的输入和输出

接受键盘输入：input()函数从标准输入读入一行文本
用户输入的全部数据以字符串的形式返回，如果需要输入数值，就必须进行类型转换

x = input("请输入0-9你最喜欢的数字：")
print(type(x),end = " : ")
print(x)

请输入0-9你最喜欢的数字：5
<class 'str'> : 5

输出处理结果：print()函数可以输出格式化的数据
print(value,…,sep = ’ ',end = ‘\n’)
value表示用户输出的多个信息，sep表示输出信息之间的分隔符，end表示输出信息之后添加的符号，默认为\n

变量

Python属于弱类型语言，可以直接声明变量名称，不必声明变量的类型，python会自动判别变量的类型
(容易犯的错误是输入数据类型错误，使用type(inputData)来测试输入数据的类型)

x = 50
y = x + 30
print(x,y)

50 80

标识符与保留字

标识符用来识别变量，函数，类，模块以及对象的名称。标识符包括英文字母，数字以及下划线
限制如下：
1.标识符的第一个字符不能为数字，并且变量之间不能存在空格
2.python语言区分大小写
3.保留字不可以当做标识符

简单数据类型

python3 中有两个简单数据类型：数字类型和字符串类型
数字类型：int float bool complex 4种数字类型
字符串类型：可以使用一对单引号，双引号，或者三引号包含起来
注意：当字符串长度超过一行时，必须使用三引号将字符串包含起来
字符串x转为数字类型：int(x),float(x)
数字类型x转为字符串：str(x)

Python数据结构

主要包括集合，列表，元祖，字典。后续会深入讲解
不可变的数据结构(字符串str、元组tuple、对象集objects，(加一个简单数据类型，数字))
可变的数据结构 (集合set，列表list，字典dict)

运算符与优先级

算术运算符，比较运算符，赋值运算符，逻辑运算符，位运算符，成员运算符(in,not in)，身份运算符(is,not is)
优先级加括号()可以解决

Python 数据结构

序列类型

序列是具有先后关系的一组元素，元素类型可能不同，类似于数学元素序列：S0,S1,S2,S3
序列元素间由下标(索引)引导，可以通过下标访问序列特定元素，存在正向递增序号和反向递减序号
序列是一个基类类型，常见的满足序列的有列表，元素，字符串
通用函数和方法：len(s) 长度 ,min(s),max(s),s.index(x)x的位置,s.count(x)计数

列表

列表是序列类型的一种扩展，十分常用
列表使用方括号[]或者list()创建，元素之间用逗号,分割，列表创建之后可以任意修改

列表的常用方法：
将ls下标i处的元素替换为x：ls[i] = x
得到ls下标i处的元素值赋值给x：x = ls[i]
将ls下标从i到j以步长为k进行切片返回一个新列表newls：newls = ls[i:j:k]
删除列表中的元素：
1.删除ls下标为i处的元素：del ls[i]
2.返回并删除ls下标为i的元素：x = ls.pop(i)
3.删除ls中首次出现指定为data的元素：ls.remove(data)
增加列表中的元素：
1.将x作为整体添加到ls的末尾：ls.append(x)
2.将列表lt中的元素按照顺序添加到ls中：ls.extend(lt) 或者 ls += lt
3.将ls中的元素重复n遍形成新列表：ls *= n
清空ls：ls.clear()
ls的拷贝结果赋给lt:lt = ls.clear() 深拷贝？后面再看看

ls = [1,2,3,4]
lt = ls.copy()
ls[2] = 8
print(lt)
print(ls)

[1, 2, 3, 4]
[1, 2, 8, 4]

将ls中元素值为vlaue的首次索引值赋给x：x = ls.index(value)

ls.append(2)
print(ls)
print(ls.index(2))

[1, 2, 8, 4, 2]
1

在ls下标为index处插入value值：ls.insert(index,value)

ls.insert(2,10)
print(ls)

[1, 2, 10, 8, 4, 2]

将value值在ls中的数目赋给x：x = ls.count(value)
列表排序：ls.sort() 默认从小到大 列表反转：ls.reverse()
len(ls),max(ls),min(ls),list(lt)：将lt中的元素转换为列表

列表最主要的作用:表示一组有序数据，进而操作它们

元祖

元祖是一种序列类型的扩展，特点：一旦创建就不能修改
使用小括号或者tuple()创建，元素间用逗号,分割
元素类型继承序列类型的全部通用操作，没有其他特性操作

tuple_a = (1)
tuple_b = (1,)
print("type(tuple_a) is ",type(tuple_a))
print("type(tuple_b) is ",type(tuple_b))

type(tuple_a) is  <class 'int'>
type(tuple_b) is  <class 'tuple'>

#元祖解包
tuple_c = (12,3,4)
a,b,c = tuple_c
print("a = ",a,"b = ",b,"c = ",c,sep = ',')

a = ,12,b = ,3,c = ,4

字符串

字符串类型的表示
字符串有2类共4种 表示方法:存在冗余
由一对单引号或双引号表示，仅表示单行字符串
“请输入带有符号的温度值:“或者 ‘C’
由一对三单引号或三双引号表示，可表示多行字符串
‘’‘Python语言’’’
如果希望在字符串中包含双引号或单引号呢？
'这里有个双引号(”)‘或者"这里有个单引号(’)”
如果希望在字符串中既包含双引号又包含单引号呢？
‘’‘这里既有单引号(’)又有双引号(")’’’

字符串的序号
正向递增序号和反向递减序号
使用[]获取字符串中的一个或者多个字符
索引：返回字符串中单个字符 <字符串>[M]
切片：返回字符串中一段字符串 <字符串>[M:N]
M缺失表示 至开头 ，N缺失表示 至结尾
“O一二三四五六七八九十”[:3] 结果是 “O一二”
<字符串>[M:N:K] ，根据步长K对字符串切片
“O一二三四五六七八九十”[1:8:2] 结果是"一三五七"
特例：字符串逆序输出
“O一二三四五六七八九十”[::-1]结果是"十九八七六五四三二一O"

字符串的特殊用法
字符串的特殊字符："\b" 回退 "\n"换行 "\r"回车
字符串处理函数：一些函数形式提供的字符串处理功能，len(x)，str(x)，hex(x)或者 oct(x)，chr(u) 或者 ord(x)

字符串处理方法
“方法” 特指 <a>.<b>()风格中的函数<b>()
返回字符串的副本，全部字符小写或大写:str.lower() 或者 str.upper()
返回一个列表，由str根据sep被分割的部分组成:str.split(sep=None)
返回字串sub在str中出现的次数:str.count(sub)
返回字符串str副本，所有old字串被替换为new:str.replace(old,new)
字符串str根据宽度width居中，fillchar可选:str.center(width,[fillchar])
从str中去掉在其左侧和右侧chars中列出的字符:str.strip(chars)
在iter变量除最后元素外每个元素后增加一个str,主要用于字符串分割:str.join(iter)

print('AbCdEfGh'.lower())
print('AbCdEfGh'.upper())
print('A,B,C'.split(','))
print('an apple a day'.count('a'))
print('python'.replace('n','n123.io'))
print('python'.center(20,'='))
print(' =python ='.strip(' =np'))
print(','.join('12345'))

abcdefgh
ABCDEFGH
['A', 'B', 'C']
4
python123.io
=======python=======
ytho
1,2,3,4,5

字符串类型的格式化:格式化是对字符串进行格式表达的方式
字符串格式化使用.format()方法 用法如下：<模板字符串>.format(<逗号分割的参数>)
python语言采用槽和format方式进行格式化
槽内部对格式化的配置方式；{<参数序号>:<格式控制标记>} 格式控制标记:<填充><对齐><宽度><,><.精度><类型>
引导符号 用于填充的单个字符 <左对齐 >右对齐 ^居中对齐 槽设定的宽度 数字的千位分隔符 浮点数小数精度或者字符串最大输出长度 整数类型b,c,d,o,x,X 浮点数类型e,E,f,%

print('{0:=^20}'.format("python"))
print('{0:*>20}'.format("BIT"))
print('{:10}'.format("BIT"))
print('{0:,.2f}'.format(123456.7896))
print("{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425))

=======python=======
*****************BIT
BIT       
123,456.79
110101001,Ʃ,425,651,1a9,1A9

集合

集合是多个元素的无需组合，与数学中集合的概念一致，满足确定性，互异性，无序性
集合使用大括号{}或者set()创建，元素之间用逗号,分开，建立空集合类型，必须使用set()
集合元素不可更改，不能是可变数据类型
集合常用来进行去重处理

字典

映射是一种键(索引)和值(数据)之间的对应
字典类型是"映射"的体现：键值对，键是对数据索引的扩展；字段是键值对的集合，键值对之间无序；采用大括号{}和dict()来创建字典，键值对之间使用冒号：表示，不同键值对之间使用逗号,分开
定义字典键值对时，需要注意字典中的键必须是不可变数据类型，即数字，字符串，元素。字典中的值没有要求

字典类型的方法
在字典中，通过键获得值 <字典变量> = {<键1>:<值1>,<键2>:<值2>,<键3>:<值3>,…}
通过 值 = <字典变量>[<键>] 这种形式来获得键对应的值
通过 <字典变量>[<键>] = 新值 如果字典中存在该键，则键对应的值使用新值覆盖，否则，字典变量新增一个键值对

d = {'a':1,'b':2,'c':3}
print(d)
print(d['b'])
d['c'] = 4
print(d)

{'a': 1, 'b': 2, 'c': 3}
2
{'a': 1, 'b': 2, 'c': 4}

删除字典中键值对：del <字典变量>[<键>]

del d['a']
print(d)

{'b': 2, 'c': 4}

如果键存在，返回其对应的值，否则返回默认值：<字典变量>.get(键[,默认值])
字典中的元素创建一个由元祖对象组成的列表：<字典变量>.items()
字典中的键值创建一个列表对象：<字典变量>.keys()
字典中的键值对应的数值创建一个列表对象：<字典变量>.values()

print(d.get('b',4))
print(d.get('d',0))
print(d.items())
print(d.keys())
print(d.values())

2
0
dict_items([('b', 2), ('c', 4)])
dict_keys(['b', 'c'])
dict_values([2, 4])

字典在实际使用中范围很广，存在映射关系的数据都可以使用字典表示
字典最主要的作用：表达键值对数据，进而操作它们 (注意键是不可以数据类型)

程序的控制结构

顺序结构，选择结构，循环结构

分支结构：根据判断条件结果而选择不同向前路径的运行方式

单分支结构：
if <条件>:
<语句块>

二分支结构：
if <条件>:
<语句块1>
else:
<语句块2>
紧凑形式：适用于简单表达式的二分支结构
<表达式1> if <条件> else <表达式2>
注意表达式的使用：不能赋值

多分支结构：
if <条件1>：
<语句块1>
elif <条件2>：
<语句块2>
…
else:
<语句块n>
注意多条件之间的包含关系；注意变量取值范围的覆盖

条件判断：操作符条件;组合：用于条件组合的三个保留字 and or not;注意缩进

x = 20
if x<0:
    print('x小于0')
else:
    print('x大于0')
    
print('x小于0') if x<0 else print('x大于0')

x大于0
x大于0

循环语句：在满足条件的情况下反复执行某一个操作
主要有for循环和while循环

b = 1;sum = 0
while b <= 20:
    sum += b
    b += 1

print("1-20的和为：",sum,sep = "")

1-20的和为：210

fruits = ['banara','apple','mango']
for i in fruits:
    print(i,end = ",")

print()
for j in range(len(fruits)):
    print(fruits[j],end = ",")

banara,apple,mango,
banara,apple,mango,

d = {'name':'Divid','age':65,"male":'department'}
for key in d:
    print(key,'corresponds to',d[key])

name corresponds to Divid
age corresponds to 65
male corresponds to department

其他关键字：
break ：用于终止最近的循环
continue：用于跳出最近的循环并执行下一次循环
pass语句用于占位，不做任何操作，保持结构的完整性

函数

自定义函数
以def语句开头，函数名称和圆括号;function代表函数名称;任何传入的参数和自变量放在圆括号内，以冒号结束;冒号下面缩进，编写函数
一般以return表达式结束函数，expression表示需要返回的结果;缺少expression的return语句相当于返回none
def function(part1,part2,…):
suite函数主体
return expression

def exponent(a,b):
    x = a**b
    print(x)
    return

exponent(3,3)

27

函数的参数：调用函数时可使用的参数类型包括必须参数，关键字参数，默认参数，可变参数和组合参数
必须参数要求用户必须以正确的顺序传入参数：调用时的数量必须和声明时一模一样。

def gg(x,y):
    return x - y

dg = gg(200,50)
# 函数赋值方式采用按照顺序赋值
print(dg)

# error1:gg()   error2:gg(100,200,300)

150

关键字参数：用户调用函数时可以使用变量名称等于变量值的形式

print(gg(x = 200,y = 100))
print(gg(y = 100,x = 200))

100
100

默认参数：调用函数时，若没有传递参数，则会使用默认值

def gg2(name,price = 600):
    print(name ,'的价格为：',price,sep = "")
    return

gg2("洗衣机")
gg2("洗衣机",800)

洗衣机的价格为：600
洗衣机的价格为：800

可变参数：用户再声明参数时不能确定需要使用多少个参数，就可以使用可变参数
形参前面加一个*(星号)：把多个位置参数值当成元祖的形式传入

def gg3(*args):
    for i in args:
        print(i,end = ",")
    return

gg3(1,2,3,4,5)

1,2,3,4,5,

形参前面加两个*(星号):关键字参数值当成字典的形式传入

def gg4(**args):
    for a in args.keys():
        print(a,end = ",")
    print()
    for b in args.values():
        print(b,end = ",")
    return

gg4(a= 1,b= 2,c= 3)

a,b,c,
1,2,3,

函数返回值
无表达式的return语句：返回None
单个表达式的return语句：返回表达式结果
多个表达式的return语句：多个表达式结果组合为元祖后进行返回

形参和实参
定义函数时，函数的参数就是形参，形参即形式上的参数，它代表参数，但是不知道具体代表的是什么参数。实参就是调用函数时的参数，即具体的，已经知道的参数

变量作用域
在函数之外定义的变量属于全局变量，用户可以在函数内使用全局变量
在函数内部定义的变量属于局部变量

匿名函数
使用lambda创建，不可重复共享
注意规则：1.匿名函数若只有一个表达式，则必须要有返回值；参数没有限制；不能有return

def gg5(x,y):
    return x+ y

gg6 = lambda x,y:x+y

print("def gg5(2,3):",gg5(2,3))
print("lambda (2,3):",gg6(2,3))

def gg5(2,3): 5
lambda (2,3): 5

对象和类

面向对象编程(OOP)：一种程序设计方法，核心就是将现实世界中的概念，过程和事务抽象成为Python中的模型
面向对象的三大特性：封装性，继承性和多态性
类(class)：具有相同属性及相同行为的一组对象，其内部包括成员变量和成员方法，分别用于描述对象的行为和方法
类是一个抽象的概念，要利用类的方式解决问题，必须先用类创建一个实例化的对象，通过对象访问类的成员变量及调用类的成员方法，来实现程序的功能

Python中使用关键字class来定义类，语法格式如下：
class ClassName:
#类变量
#构造函数(实例变量)
#函数

创建类的对象： ObjectName = ClassName(参数1,参数2,…)

class Fruit:
    fruCount = 0 #定义类实例fruCount
    def __init__(self,name,price):  #
        self.name = name  # 实例变量，以self为前缀
        self.price = price
        zone = "China"   #局部变量，不以self为前缀
        
    def displayFriuts(self):
        print("名称:",self.name,"价格是:",self.price)
        
f = Fruit("苹果",12.3)
f.displayFriuts()

名称: 苹果 价格是: 12.3

封装：顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容
主要体现对变量的封装，私有的变量前面加两条下划线,这样就不能在类的外面调用它

class A:
    __N = 66 #类私有变量
    
    def func(self):
        print(A.__N)
        
a = A()
a.func()

66

继承：新的类可以继承一个，或多个父类，子类会得到父类中的属性和方法，在此基础上，可以定义子类特有的属性和方法，也可以对父类中的方法进行重写
class Parent1: #父类Parent1
pass

class Parent2: #父类Parent2
pass

class Son1(Parent1): #单继承，
pass

class Son2(Parent1,Parent2): #多继承，用逗号分割开多个继承的类
pass

class Animal:
    
    def __init__(self,name,age):
        self.name = name
        self.age = age
    
    def display(self):
        print("名称:",self.name,"年龄是:",self.age)
        
class Dog(Animal):
    def display(self):   #重写父类中的display()方法
        print("我是一条狗","名称:",self.name,"年龄是:",self.age)
        
class Cat(Animal):
    def __init__(self,name,age,color):
        # 在单继承中，super负责找到当前类所在的父类，这个时候就不需要再手动传self
        super().__init__(name, age)    # 这个比较常用
        self.color = color
    
    def displayCat(self):
        super().display()   # 调用父类的方法
        print("我是一只猫","名称:",self.name,"年龄是:",self.age,"颜色是:",self.color)
        
dog = Dog("大黄",2)
dog.display()
cat = Cat("咪咪",3,"white")
cat.displayCat()

我是一条狗 名称: 大黄 年龄是: 2
名称: 咪咪 年龄是: 3
我是一只猫 名称: 咪咪 年龄是: 3 颜色是: white

多态：父类的引用指向子类的对象
python是自带多态效果的，且崇尚鸭子类型
Pyhon不支持Java和C#这一类强类型语言中多态的写法，但支持原生多态，其Python崇尚“鸭子类型。所谓的鸭子类型，说白了就是两个不同的类拥有相同的方法名，利用一个统一的接口来调用，不同的对象在接收时会产生不同的行为（即方法）

鸭子类型：不是通过具体的继承关系来约束某些类必须必须要有哪些方法名，是通过一种约定俗成的概念来保证多个类中相似的功能叫相同的名字

参考文献

链接：python中的类和对象
链接：python中的类和对象，属性和方法
链接：王英英 Python 3.8 从入门到精通