【python复习笔记】

一、列表

1、查找列表元素值索引

index()方法：用于从列表中找出某个值第一个匹配项的索引位置。

语法：listname.index(x,start,end)

• listname-- 列表名
• x-- 查找的对象。
• start-- 可选，查找的起始位置。
• end-- 可选，查找的结束位置。

如：list.index('python') 返回的结果是list列表中python这个元素对应的索引值。

2、列表添加元素

①、append()方法：用于在列表的末尾追加元素

语法：listname.append(x)

• listname-- 需要添加元素的列表名
• x-- 添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

②、extend()方法：用于在列表的末尾追加元素

语法：listname.extend([x])

• listname-- 需要添加元素的列表名
• x-- 添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。
• 注意：x的那个[]最好要加上

③、insert()方法：用于在列表中间某个位置插入元素

语法：listname.insert(index, x)

• listname-- 需要添加元素的列表名
• index-- 指定插入位置的索引值
• x-- 添加到列表指定位置的数据，它可以是单个元素，也可以是列表、元组等。

④、合并方法：利用列表的切片操作，将两个列表进行合并。

3、列表删除元素

①、def方法：根据索引值删除元素

语法：def listname[index] 或 del listname[start, end]

• listname-- 需要删除元素的列表名
• index-- 需要删除的元素的索引值
• start-- 起始索引
• end-- 结束索引
• 注意：del 会删除从索引 start 到 end 之间的元素，不包括 end 位置的元素

②、pop()方法：根据索引值删除元素

语法：listname.pop(index)

• listname-- 需要删除元素的列表名
• index-- 需要删除的元素的索引值
• 注意：如果不写 index 参数，默认会删除列表中的最后一个元素

③、remove()方法：根据元素值删除元素

语法：listname.remove(x)

• listname-- 需要删除元素的列表名
• x-- 需要删除的元素
• 注意：remove()方法一次删除一个元素；重复的元素只删除第一个；元素不存在时，会抛出错误。

④、clear()方法：清空列表

语法：listname.clear()

• listname-- 需要删除元素的列表名

4、列表排序

①、sort()方法

语法：listname.sort(reverse=)

• listname-- 需要进行排序的列表名
• 参数reverse-- 为True时，表示降序排序；为Flase时，表示升序排序；默认为升序排序。

②、sorted()方法

语法：sorted(listname, reverse= )

• listname-- 需要进行排序的列表名
• 参数reverse-- 为True时，表示降序排序；为Flase时，表示升序排序；默认为升序排序。

③、两种方法的区别

sort()方法是在原列表的基础上，直接排序，会改变原列表；
sorted()方法会将排序结果保留到新的列表中，原列表不会改变。

5、列表生成式

'''
举一个例子，将偶数筛选出来，放到一个列表里，打印这个列表
'''
# 一般的写法

li1 = []
for i in range(1, 10):
    if i % 2 == 0:
        li1.append(i)
print('一般写法的输出结果：', li1)

# 列表生成式的写法
li2 = [i for i in range(1, 10) if i % 2 == 0]
print('列表生成式的输出结果：', li2)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

结果如下：

一般写法的输出结果： [2, 4, 6, 8]
列表生成式的输出结果： [2, 4, 6, 8]
1
2

二、字典

1、字典元素的获取

①、[ ]方法

语法：dictname["key"]

• dictname-- 字典名
• key-- 元素对应键名

②、get()方法

语法：dictname.get("key")

• dictname-- 字典名
• key-- 元素对应键名

③、两种方法的区别
[ ]方法，找不到对应的key，会报一个KeyError错误；
get方法，找不到对应的key，会返回None，也可以通过参数设置，使返回值不是None，而是设定的值。

如：

result = dictname.get("key", 'error')
1

如果key不是dictname字典中存在的键，那么打印result的结果是error。

2、字典添加元素

①、[ ]方法

语法：dictname[key] = value

• dictname-- 需要添加元素的字典名
• key-- 指定一个dictname字典中不存在的key（如果dictname字典中存在key，则是修改操作）作为添加的元素的key
• value-- 添加的元素的value值

②、update()方法

语法1：dictname.update({key : value})
语法2：dictname.update(key = value)

• dictname-- 需要添加元素的字典名
• key-- 指定一个dictname字典中不存在的key（如果dictname字典中存在key，则是修改操作）作为添加的元素的key
• value-- 添加的元素的value值

3、字典删除元素

①、pop()方法

语法：dictname.pop(key)

• dictname-- 需要删除元素的字典名
• key-- 需要删除元素对应的key

②、del方法

语法：del dictname[key]

• dictname-- 需要删除元素的字典名
• key-- 需要删除元素对应的key

③、clear()方法：用于清空字典

语法：dictname.clear()

• dictname-- 需要清空的字典名

4、获取字典的视图

keys = dictname.keys()  # 获取所有key组成的视图
values = dictname.values()  # 获取所有value组成的视图
items = dictname.items()  # 获取所有key-value对，组成的视图
1
2
3

• dictname-- 字典名

5、字典生成式

示例如下：

'''
将字典的key与value位置互换
'''
dict1 = {"one": 1, "two": 2, "three": 3}

dict2 = {value: key for key, value in dict1.items()}

print(dict2)
1
2
3
4
5
6
7
8

输出结果：

{1: 'one', 2: 'two', 3: 'three'}
1

三、集合

1、集合新增元素

①、add()方法：一次添加一个元素

语法：setname.add(x)

• setname-- 添加元素的集合名
• x-- 添加的元素

②、update()方法：一次添加多个元素

语法：setname.update(x)

• setname-- 添加元素的集合名
• x-- 添加的元素

示例如下：

a = set('str')
a.add('python')

b = set('str')
b.update('python')

c = {1, 2, 3}
c.add(80)

d = {1, 2, 3}
d.update([10, 20, 30])

'''
d.update([10, 20, 30])   也可以写成

d.update({10, 20, 30})
d.update((10, 20, 30))
'''

print(a)
print(b)
print(c)
print(d)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

输出结果：

{'python', 't', 'r', 's'}
{'n', 'r', 'h', 'o', 'y', 'p', 's', 't'}
{80, 1, 2, 3}
{1, 2, 3, 10, 20, 30}
1
2
3
4

2、集合删除元素

①、remove()方法：删除指定元素

语法：setname.remove(element)

• setname-- 集合名
• element-- 需要删除的元素

②、discard()方法：删除指定元素

语法：setname.discard(element)

• setname-- 集合名
• element-- 需要删除的元素

remove()方法和discard()方法的区别：

使用 remove 方法删除元素时，如果元素不存在集合中，那么程序会报错。
使用 discard 方法删除元素时，如果元素不存在集合中，那么程序不会报错。

③、pop()方法：删除第一个元素，并返回删除的元素

语法：setname.pop()

• setname-- 集合名

④、clear()方法：清空集合

语法：setname.clear()

• setname-- 集合名

示例如下：

a = {1, 2, 3, 4, 5}
a.remove(2)
print(a)

b = {1, 2, 3, 4, 5}
b.discard(3)
print(b)

c1 = {1, 2, 3, 4, 5}
c2 = c1.pop()
print(c1)
print(c2)

d = {1, 2, 3, 4, 5}
d.clear()
print(d)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出结果：

{1, 3, 4, 5}
{1, 2, 4, 5}
{2, 3, 4, 5}
1
set()
1
2
3
4
5

3、集合生成式

相比与列表生成式，只是将 [ ] 改成了 { } ;
如果你想去除重复的元素，可以使用集合生成式。

四、字符串

1、字符串的分割

split()方法：指定分隔符对字符串进行切片

语法：strname.split(x)

• strname-- 字符串名
• x-- 指定的分隔符

2、字符串的替换

replace()方法：把字符串中的旧字符串替换成新字符串

语法：strname.replace(old, new)

• strname-- 字符串名
• old-- 将被替换的子字符串
• new-- 新字符串，用于替换old子字符串

3、字符串的合并

①、+ 方法

通过+这个符号来拼接字符串

②、join()方法：将列表（或元组）中多个字符串采用固定的分隔符连接在一起

语法：newstr = str.join(iterable)

• newstr-- 合并后生成的新字符串
• str-- 指定合并时的分隔符
• iterable-- 做合并操作的源字符串数据

lie = ['www', 'baidu', 'com']
newstr = '.'.join(lie)
print(newstr)
1
2
3

输出结果：

www.baidu.com
1

五、异常处理机制

try:
    # 这部分写不能确定正确执行的代码
except Exception as e:
    print('未知错误 %s' %e)
1
2
3
4

六、类和对象

1、定义类

定义类的基本语法如下：

class 类名:
    多个（≥0）类属性...
    多个（≥0）类方法...
1
2
3

2、类变量和实例变量

类体中、所有函数之外：此范围定义的变量，称为类属性或类变量；
类体中，所有函数之内：以“self.变量名”的方式定义的变量，称为实例属性或实例变量；

class Person():

    introduce = "大家好！"   # 类属性

    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age    # 实例属性
        
1
2
3
4
5
6
7
8

3、实例方法、类方法和静态方法

不用任何修改的方法为实例方法；
采用 @classmethod 修饰的方法为类方法；
采用 @staticmethod 修饰的方法为静态方法。

class Person():
    
    def say(self):
        print("正在调用实例方法")
        
    @classmethod
    def eat(cls):
        print("正在调用类方法")
        
    @staticmethod
    def drink():
        print("正在调用静态方法")

1
2
3
4
5
6
7
8
9
10
11
12
13

4、类对象的创建和调用实例方法

class Person():

    def say(self):  # 实例方法
        print("我是张三")

zhang = Person()  # 创建类对象，zhang

"""
类对象调用实例方法的两种方式：
1、通过类对象名调用实例方法
2、通过类名直接调用实例方法

"""
zhang.say()
Person.say(zhang)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

5、封装

如果类中的变量和函数，其名称以双下划线“__”开头，则该变量（函数）为私有变量（私有函数），从而实现类的封装。

参考：

https://blog.csdn.net/sinat_38682860/article/details/109560354

6、继承

实现继承的类称为子类，被继承的类称为父类（也可称为基类、超类）。

子类继承父类时，只需在定义子类时，将父类（可以是多个）放在子类之后的圆括号里即可。语法格式如下：
（具有多个父类，即为多继承）

class 类名(父类1, 父类2, ...)：
    #类定义部分
1
2

注意：如果该类没有显式指定继承自哪个类，则默认继承 object 类。
（object 类是 Python 中所有类的父类，即要么是直接父类，要么是间接父类）

class People:
    def say(self):
        print("我是一个人，名字是：",self.name)
class Animal:
    def display(self):
        print("人也是高级动物")
#同时继承 People 和 Animal 类
#其同时拥有 name 属性、say() 和 display() 方法
class Person(People, Animal):
    pass
zhangsan = Person()
zhangsan.name = "张三"
zhangsan.say()
zhangsan.display()
1
2
3
4
5
6
7
8
9
10
11
12
13
14

有继承，就要有重写。重写指的是对类中已有方法的内部实现进行修改。

class Bird:
    #鸟有翅膀
    def isWing(self):
        print("鸟有翅膀")
    #鸟会飞
    def fly(self):
        print("鸟会飞")
class Ostrich(Bird):
    # 重写Bird类的fly()方法
    def fly(self):
        print("鸵鸟不会飞")
# 创建Ostrich对象
ostrich = Ostrich()
# 调用被重写的方法
ostrich.fly()
# 调用 Bird 类中的 fly() 方法 || 调用未被重写的方法
Bird.fly(ostrich)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在子类中的构造方法中，调用父类构造方法的方式：使用 super() 函数。但如果涉及多继承，该函数只能调用第一个直接父类的构造方法。

class People:
    def __init__(self, name):
        self.name = name
        
    def say(self):
        print("我是人，名字为：", self.name)
        
        
class Animal:
    def __init__(self, food):
        self.food = food
        
    def display(self):
        print("我是动物,我吃", self.food)
        

class Person(People, Animal):
    # 自定义构造方法
    def __init__(self, name, food):
        # 调用 People 类的构造方法
        super().__init__(name)
        # super(Person,self).__init__(name) #执行效果和上一行相同
        # People.__init__(self,name)#使用未绑定方法调用 People 类构造方法
        # 调用其它父类的构造方法，需手动给 self 传值
        Animal.__init__(self, food)
        
        
per = Person("zhangsan", "熟食")
per.say()
per.display()

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

7、多态

类的多态特性的前提条件：

• 继承：多态一定是发生在子类和父类之间；
• 重写：子类重写了父类的方法。
• 同一变量可能会被先后赋值不同的类对象。

class CLanguage:
    def say(self):
        print("调用的是 Clanguage 类的say方法")
class CPython(CLanguage):
    def say(self):
        print("调用的是 CPython 类的say方法")
class CLinux(CLanguage):
    def say(self):
        print("调用的是 CLinux 类的say方法")
a = CLanguage()
a.say()
a = CPython()
a.say()
a = CLinux()
a.say()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Python 这种由多态衍生出的更灵活的编程机制，被称为“鸭子模型”或“鸭子类型”。例子如下：

class WhoSay:
    def say(self,who):
        who.say()
class CLanguage:
    def say(self):
        print("调用的是 Clanguage 类的say方法")
class CPython(CLanguage):
    def say(self):
        print("调用的是 CPython 类的say方法")
class CLinux(CLanguage):
    def say(self):
        print("调用的是 CLinux 类的say方法")
a = WhoSay()
#调用 CLanguage 类的 say() 方法
a.say(CLanguage())
#调用 CPython 类的 say() 方法
a.say(CPython())
#调用 CLinux 类的 say() 方法
a.say(CLinux())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

此程序中，通过给 WhoSay 类中的 say() 函数添加一个 who 参数，其内部利用传入的 who 调用 say() 方法。这意味着，当调用 WhoSay 类中的 say() 方法时，我们传给 who 参数的是哪个类的实例对象，它就会调用那个类中的 say() 方法。