Posted on | In |

理解 匿名函数 基础

常规函数：

1
2
3
4
def add(x):
    return x + 1

print(add(5))

6

匿名函数

1
print((lambda x: x + 1)(5))

6

匿名函数格式
lambda 参数1，参数1，参数1，…参数n : 表达式
应用场景：如果代码有很多重复，往往要将重复代码抽成一个方法函数，然后在需要的地方调用就可以了
有一种情况是：函数只用一次就不要了，这时候就可以使用匿名函数 lambda 上场，简化代码
一般函数传参：

1
2
3
def add(x, y):
    return x + y
print(add(1, 2))

3

匿名函数传参
添加 () 传参

1
2
print((lambda x, y: x + y)(10, 20))
(lambda *args: print(args))(1, 2)

30
(1, 2)

这句代码的意思是说
遍历 0-9 这 10 个数字
然后把每个数逐个交给匿名函数处理
处理的方式就是 x % 2
最后将得到的结果放进列表里面

1
2
my_list = [(lambda x: x % 2)(x) for x in range(10)]
print(my_list)

[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

所谓 “匿名”
说的就是这个函数没有定义名称
不再像我们之前使用自定义函数那样
还必要给函数起个名称

下面是使用传统函数实现以上方法，仔细看区别之处
使用匿名函数极大的简化了代码量，
使用匿名函数使程序主逻辑更清晰，但前提是：能理解匿名函数的实现功能细节
能否看懂别人写的匿名函数将是关键点，这一点与 Excel 中的公式相似

匿名函数：无名函数
传统函数：有名函数

1
2
3
4
5
6
7
def get_list(n):
    my_list2 = []
    for i in range(n):
        my_list2.append(i % 2)
    return my_list2

print(get_list(10))

[0, 1, 0, 1, 0, 1, 0, 1, 0, 1]

避免为了匿名而匿名，画蛇添足
像下面这样的代码
虽然定义了匿名函数，但还是返回来像传统有名函数那样调用，就应尽量避免

1
2
add = (lambda x, y: x + y)
print(add(1, 2))

3

匿名函数在啥时候用呢？

匿名函数在那些只需要执行一次就不要了的场景中使用
可以想到在函数式编程中将运用很广泛
结合 Python 中的 map() filter() 这两个函数高效使用

map() 函数

map(函数对象，序列)
map函数有两个参数
第一个可以传入 函数 ， 第二个传入 序列
当执行这个 map 时，序列里面的每个值都会被取出，然后拿去执行传入的函数

map函数结合传统有名函数使用

1
2
3
4
5
6
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

def add(x):
    return x + 5

print(list(map(add, my_list)))

[6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

map 函数结合匿名函数使用

1
2
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list(map((lambda x: x + 5), my_list)))

[6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

filter() 函数

filter(函数对象，序列)
filter 中传入的函数对象一般用于判断
过滤判断提取出：一个列表中的数 %2 是等于 0 的数，

1
print(list(filter((lambda x: x % 2 == 0), my_list)))

[2, 4, 6, 8, 10]

Posted on | In |

在同一目录下自定义模块 calc.py，供其它文件调用

1
2
3
4
5
6
7
8
9
10
11
12
from functools import reduce
import operator
def add(*number):
    return sum(number)

def product(*number):
    return reduce(operator.mul, number, 1)

# 避免被调用 import 时执行以下代码，否则这两个print 在被import 时会被自动执行
if __name__ == '__main__':
    print(add(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
    print(product(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))

模块： 函数 类 的存放之地，高级
需要将代码进行模块化，
将代码进行归类，整理好，以后方便使用和检索
模块化的好处在项目越来越大的时候最能体现出来

当使用 import 时，Python 解释器按下列顺序查找相应模块
当前文件路径 ——》Python 设置的环境变量 ——》系统默认路径（python 安装路径）

import 一般写在程序的最前面，这是因为 python 对 import 只执行一次，
不会导入重复的模块进来

在同一目录下，直接 import 模块名称 导入

需要指定模块名 calc

1
2
3
import calc
print(calc.add(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
print(calc.product(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))

55
3628800

from 模块名 import 具体函数

这种方式只引用模块中的部分方法
在调用方法时不需要指定模块名 calc ,直接写方法名 product

1
2
from calc import product
print(product(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))

from 模块名 import *

应用模块下所有内容
在调用方法时不需要指定模块名 calc ,直接写方法名 product

1
2
3
from calc import *
print(add(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
print(product(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))

55
3628800

使用包 packages 引用

包 package 实际就是一个目录
比直接在当前目录下引用多了一层目录路径的描述
from 包名（目录名）.模块名 import 方法

1
2
3
4
5
6
7
8
from sub_package.calc import add, product
from sub_package2.calc import add as add2, product as product2

print(add(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
print(product(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))

print(add2(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
print(product2(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))

引用的 sub_package
55
引用的 sub_package
3628800
引用的 sub_package2
55
引用的 sub_package2
3628800

Posted on | In |

所谓注释，就是给人看的，不会被电脑执行的一些“人话”解释

为了让你的代码能够易于理解，易于阅读，
让别人或者往后的你自己回过头来看你写的代码，
也能够快速理解，知道你写的这些代码是干嘛的。

你必须好好的写好代码注释

单行注释

1
2
3
4
5
6
7
8
9
10
11
12
13
import requests
# 根据 url 下载网页内容
def download_html(url):
    try:
        # 通过 request 的 get 请求链接
        response = requests.get(url, headers=headers)  # header 要预先定义
        # 如果返回状态码是 200 ，说明请求成功
        if response.status_code == 200:
            # 返回网页内容
            return response.content
    except requests.RequestException:
        # 请求出现异常，错误捕获处理
        return None

行内注释

1
new_image = Image.new('RGB', (260, 126))  # 创建一张大小相同的图片

多行注释

1
2
3
4
5
6
7
8
9
10
11
12
13
"""
这个 main 函数会接收一个 page 参数，然后构建一个可请求的链接 url
然后使用 request_test 请求这个链接就会得到这个网页的内容 html
接着利用 parse_result 解析得到的 html ，从而获取需要的关键字段信息
最后使用 write_item_to_file 把信息写入文件
"""

def main(page):
    url = 'http://www.example.com/' + str(page)
    html = requests_test(url)
    items = parse_result(html)
    for item in items:
        write_item_to_file(item)

Posted on | In |

操作目录

创建目录

1
2
import os
os.mkdir('test')

重命名目录

1
os.rename("test", "test_dir")

获取当前目录路径

1
print(os.getcwd())

G:\Python\python快速入门\python操作文件

切换目录

1
2
os.chdir('test_dir')
print(os.getcwd())

G:\Python\python快速入门\python操作文件\test_dir

删除目录

注意不能删除当前目录

1
os.rmdir('test_dir')

操作文件

打开文件

1
2
my_file = open('file.txt')
print(my_file.read())

旅行的迷人之处正是在这里
扛着不轻不重的今生

逐行读取

1
print(my_file.readline())

旅行的迷人之处正是在这里

只读模式打开

1
my_file = open('file.txt', mode='r')

字节模式读取

1
2
my_file = open('file.txt', mode='rb+')
print(my_file.readline())

b’\xc2\xc3\xd0\xd0\xb5\xc4\xc3\xd4\xc8\xcb\xd6\xae\xb4\xa6\xd5\xfd\xca\xc7\xd4\xda\xd5\xe2\xc0\xef\r\n’

写入文件

覆盖原文件

1
2
my_file = open('file.txt', mode='wt', encoding='utf-8')
my_file.write('旅行的迷人之处正是在这里')

追加

1
2
3
my_file = open('file.txt', mode='at', encoding='utf-8')
my_file.write('\r\n扛着不重不轻的今生，')
my_file.write('\r\n到处浏览自己的前生和来世。')

旅行的迷人之处正是在这里，
扛着不重不轻的今生，
到处浏览自己的前生和来世。

关闭文件

1
my_file.close()

重命名文件

1
os.rename('file.txt', '666.txt')

删除文件

1
os.remove('666.txt')

浏览目录下全部文件

1
print(os.listdir())

[‘test.txt’, ‘opt_file.py’, ‘file.txt’]

Posted on | In |

添加异常处理代码是为了让程序在遇到异常时能继续执行，
而不是一有异常错误就直接挂了
在无法确定代码是否能够顺利成功执行
或者知道代码可能存在一些错误的时候，需要把异常预先处理好。

try语句块中0作为除数，发生异常

1
2
3
4
try:
    x = 1/0
except ZeroDivisionError as err:
    print('程序发生异常，错误信息： {}'.format(err))

程序发生异常，错误信息： division by zero

异常处理常用方法

匹配多种异常的两种方法

异常分开写
这里匹配的是：ZeroDivisionError 异常

1
2
3
4
5
6
try:
    x = 1/0
except IndexError as err:
    print('程序发生 IndexError 异常， 错误信息：{}'.format(err))
except ZeroDivisionError as err:
    print('程序发生 ZeroDivisionError 异常，错误信息：{}'.format(err))

程序发生 ZeroDivisionError 异常，错误信息：division by zero

异常代码合起来写，让代码更简洁些

1
2
3
4
try:
    x = 1/0
except (IndexError, ZeroDivisionError, FileNotFoundError) as err:
    print('程序发生 某种 异常， 错误信息：{}'.format(err))

程序发生 某种 异常， 错误信息：division by zero

异常的超类是：Exception ,捕获一切异常

以下两种写法效果都能捕获异常
区别是第二种简写不能捕获具体为哪种异常，只能笼统的输出异常

1
2
3
4
5
6
7
8
9
try:
    x = 1/0
except Exception as err:
    print('程序发生 某种 异常， 错误信息：{}'.format(err))
    
try:
    x = 1/0
except:
    print('程序发生 某种 异常， 错误信息：')

程序发生 某种 异常， 错误信息：division by zero
程序发生 某种 异常， 错误信息：

finally语句

总会被执行，不管有没有异常发生

1
2
3
4
5
6
try:
    x = 1/0
except:
    print('程序发生 某种 异常， 错误信息：{}')
finally:
    print('一定会被执行的 finally 语句块')

程序发生 某种 异常， 错误信息：{}
一定会被执行的 finally 语句块

else 语句的理解

1
2
3
4
5
6
7
8
9
try:
    with open('test.txt') as f:
        f.read()
except FileNotFoundError as err:
    print('文件不存在，{}'.format(err))
else:
    print('文件已打开，可以进一步操作了！')
finally:
    print('最后一定会干的事情')

‘test.txt’ 文件不存在的情况

文件不存在，[Errno 2] No such file or directory: ‘test.txt’
最后一定会干的事情

‘test.txt’ 文件存在的情况

文件已打开，可以进一步操作了！
最后一定会干的事情

自定义异常类

由于异常的超类是：Exception
所有自定义的异常类要继承：Exception 基类

直接实例化Exception类抛出异常

1
2
3
4
err = Exception('自己抛出一个异常')
print(err.__sizeof__())
print(err.__str__())
raise err

32
自己抛出一个异常
Exception: 自己抛出一个异常

继承基类Exception，创建自定义异常类

1
2
3
class MyException(Exception):
    pass
raise MyException('用自定义的异常类抛出一个异常')

raise MyException(‘用自定义的异常类抛出一个异常’)
main.MyException: 用自定义的异常类抛出一个异常

重写基类init, str

1
2
3
4
5
6
7
8
9
10
11
12
13
class MyError(Exception):
    def __init__(self, value):
        super(MyError, self).__init__(self)
        self.value = value

    def __str__(self):
        return self.value

try:
    error = MyError('自定义异常')
    raise error
except MyError as err:
    print(err)

自定义异常

Posted on | In |

单继承

定义父类Person

1
2
3
4
5
6
7
8
class Person():
    def __init__(self, name, age):
        print('Person.__init__() 被调用')
        self.name = name
        self.age = age

    def eat(self, food):
        print(self.name, "正在吃{}".format(food))

使用super()调用父类的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class YellowPeople(Person):
    def __init__(self, name, age, weight):
        print('YellowPeople.__init__() 被调用')
        # 调用父类（基类）的初始化两种方法__init__()
        # 1.直接使用父类名称调用，需要传入self
        # Person.__init__(self, name, age)
        # 2.使用super()调用
        super().__init__(name, age)
        self.weight = weight

    def print_some(self):
        print(self.name, '今年 {} 岁， 体重 {} 斤'.format(self.age, self.weight))

xiaoming = YellowPeople('xiaoming', 18, 110)
xiaoming.print_some()

直接使用父类的名称进行调用
与super()方式调用的区别是多传入了个self参数
可以看出使用super()方式调用更简洁

1
2
3
4
5
6
7
8
9
10
class YellowPeople(Person):
    def __init__(self, name, age, weight):
        Person.__init__(self, name, age)
        self.weight = weight

    def print_some(self):
        print(self.name, '今年 {} 岁， 体重 {} 斤'.format(self.age, self.weight))

xiaoming = YellowPeople('xiaoming', 18, 110)
xiaoming.print_some()

可以看到init()的调用顺序：先子类，后父类

YellowPeople.init() 被调用
Person.init() 被调用
xiaoming 今年 18 岁， 体重 110 斤

多继承

同时继承多个父类

拥有所有父类的属性方法

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
32
33
34
35
36
class Person():

    def __init__(self, name, age):
        print('Person.__init__() 被调用')
        self.name = name
        self.age = age

    def eat(self, food):
        print(self.name, "调用的是 Person 方法，正在吃{}".format(food))
		
class YellowPeopleFather(Person):
    def play(self):
        print('黄种人的 play 方法')

    def eat(self, food):
        print(self.name, '调用的是 YellowPeopleFather 方法， 正在吃{}'.format(food))
    pass

class WhitePeopleMother(Person):
    def say(self):
        print('白种人的 say 方法')

    def eat(self, food):
        print(self.name, '调用的是 WhitePeopleMother 方法， 正在吃{}'.format(food))
    pass

class son(YellowPeopleFather, WhitePeopleMother):
    def eat(self, food):
        print(self.name, '调用的是 son 方法，正在吃{}'.format(food))
    pass

# 查看类的__mro__属性，用于调用
print(son.__mro__)
xiaozhang = son('xiaozhang', 18)
xiaozhang.play()
xiaozhang.say()

(<class ‘main.son’>, <class ‘main.YellowPeopleFather’>, <class ‘main.WhitePeopleMother’>, <class ‘main.Person’>, <class ‘object’>)
Person.init() 被调用
黄种人的 play 方法
白种人的 say 方法

所有父子类都有相同的eat()方法，如何调用指定的类

son类本身就有eat方法，直接调用

1
2
3
4
5
6
7
class son(YellowPeopleFather, WhitePeopleMother):
    def eat(self, food):
        print(self.name, '调用的是 son 方法，正在吃{}'.format(food))
    pass
	
xiaozhang = son('xiaozhang', 18)
xiaozhang.eat('food')

xiaozhang 调用的是 son 方法，正在吃food

调用YellowPeopleFather 类中的 eat 方法

1
2
3
4
class son(YellowPeopleFather, WhitePeopleMother):
    def eat(self, food):
        super().eat('food')
    pass

xiaozhang 调用的是 YellowPeopleFather 方法， 正在吃food

调用WhitePeopleMother 类中的 eat 方法

1
2
3
4
class son(YellowPeopleFather, WhitePeopleMother):
    def eat(self, food):
        super(YellowPeopleFather, self).eat('food')
    pass

xiaozhang 调用的是 WhitePeopleMother 方法， 正在吃food

调用Person 类(基类)中的 eat 方法

1
2
3
4
class son(YellowPeopleFather, WhitePeopleMother):
    def eat(self, food):
        super(WhitePeopleMother, self).eat('food')
    pass

xiaozhang 调用的是 Person 方法，正在吃food

总结：super调用的本质是调用MRO顺序的下一个类，

Posted on | In |

面向对象: 有一句话是这么说的：“世间万物，皆为对象”

对象实例化首先调用init进行初始化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 对象实例化首先调用__init__进行初始化
# self: 实例本身, name、age: 类属性，实例属性
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
# 这里的self参数就是xiaoming
xiaoming = Person('小明', 12)
print(xiaoming.name)
print(xiaoming.age)
# 这里的self参数就是xiaohong
xiaohong = Person('小红', 13)
print(xiaohong.name)
print(xiaohong.age)
# 类一定是实例化后才发生作用，不实例不能用里面的属性方法

小明
12
小红
13

定义共有的变量，在类里面定义

所有类的实例都可以访问

1
2
3
4
5
6
7
8
9
10
class Person:
    attr = '高级智慧'
    def __init__(self, name, age):
        self.name = name
        self.age = age

xiaoming = Person('小明', 12)
xiaohong = Person('小红', 13)
print(xiaoming.attr)
print(xiaohong.attr)

高级智慧
高级智慧

定义方法，实现各种功能

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Person:
    attr = '高级智慧'
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def say(self, something):
        return '%s 说 %s' % (self.name, something)

    def eat(self, food):
        return '{} 吃 {}'.format(self.name, food)

xiaoming = Person('小明', 12)
xiaohong = Person('小红', 13)
print(xiaoming.say('哈哈哈哈哈哈哈哈哈哈哈哈'))
print(xiaohong.eat('苹果苹果苹果苹果苹果苹果'))

小明 说 哈哈哈哈哈哈哈哈哈哈哈哈
小红 吃 苹果苹果苹果苹果苹果苹果

Posted on | In |

查找

1
2
3
4
str1 = '天好蓝，太阳好大，学习python的路上好嗨，来来来，不要停。。。'
print(str1.find('python')) # 找到返回索引值
print(str1.find('Python')) # 找不到返回-1
print(str1[11:17])

11
-1
python

替换

貌似不能改变原字符串，只有新建一个

1
2
3
4
str2 = str1.replace("天好蓝", "好个天")
print(str2)
# str1还是str1，并没改变
print(str1)

好个天，太阳好大，学习python的路上好嗨，来来来，不要停。。。
天好蓝，太阳好大，学习python的路上好嗨，来来来，不要停。。。

分割

1
2
3
4
str3 = '9/23/2019 11:46:57 AM'
print(str3.split(' '))
print(str3.split(' ')[0].split('/'))
print(str3.split(' ')[1].split(':'))

[‘9/23/2019’, ‘11:46:57’, ‘AM’]
[‘9’, ‘23’, ‘2019’]
[‘11’, ‘46’, ‘57’]

删除空格

只能删首位含有空格的

1
2
str4 = '                建国 70 周年阅           兵 '
print(str4.strip())

建国 70 周年阅            兵

大小写转换

1
2
3
str5 = 'congratulation'
print(str5.upper())
print(str5.lower())

CONGRATULATION
congratulation

判断开头结尾

1
2
3
str6 = '重庆磁器口.jpg'
print(str6.startswith('重庆'))
print(str6.endswith('jpg'))

True
True

Posted on | In |

鱼式游泳自学教室（全浸式自由泳）

超人漂浮

(https://www.bilibili.com/video/av13026782/?p=1)
轻松有效的超人打腿，安静、轻松、悠闲，腿不下沉即可
放松头部，双臂与肩同宽，体会无重状态
这里有个双臂同时回收到大腿的动作，总做不好！！！
一收双臂感觉身体是上浮，而前进得很少，
技巧：往后划，平行于水面，转体后加速划？

滑行

(https://www.bilibili.com/video/av13026782/?p=2)
一手前伸，一手贴大腿，转体，一侧肩膀露出水面，不划手只打腿滑行
体会平衡感觉，
体会转体过渡带来的失衡下沉感觉
体会重心转移带来的前进力量，
转体后一边肩膀露出水面，头部放松不转动
左右都转，体会双臂似两条轨道的感觉

换气

(https://www.bilibili.com/video/av13026782/?p=3)
不划手：
旋转身体换气，仰躺
向上转体，身体先转，头后转，向下则同时转
多练习一手臂在前，一手贴于大腿滑行换气的动作
划手：
要在滑行中换气，手划完的时候，不要边划手边换气，这样容易成下压换气的错误动作
换气前后都要先滑行，换完气后先滑行再划下次手
用1、2、3节奏，这样两边都可以练习到

水下换手

(https://www.bilibili.com/video/av13026782/?p=4)
换手时不出水面，手在头侧的位置停留检查，记住这个位置，然后换手，
做好的体会重心转移带来的前进力量，让你不费力前进
体会屁股发力带动手臂前伸，而非用力推水身后，
体会前伸把手掷向目标的感觉

整合1-4节

(https://www.bilibili.com/video/av13026782/?p=5)
水下换手，连续换气
水下连续换手，全泳

摇臂

(https://www.bilibili.com/video/av13026782/?p=6)
高肘
小臂放松不紧绷，
手在水中不出水面
体会木偶小臂，这要关闭小臂肌肉

加强练习

三次水下换手
换气滑行
三次摇臂换手
换气滑行
全泳
单臂划手换气练习
(https://www.bilibili.com/video/av13026782/?p=7)
(https://www.bilibili.com/video/av13026782/?p=8)
(https://www.bilibili.com/video/av13026782/?p=9)

两拍打水

水下换手、摇臂换手结合两拍打水
一下一下的打腿，打腿角度略加大，能强烈感觉打水将手送至目标定位的力量，
体会全身连接的舒畅力量输出前进的感觉
(https://www.bilibili.com/video/av13026782/?p=10)

Posted on | In |

列表

查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
tobaccos = [
    '黄鹤楼(软珍品)', '中南海(硬酷爽风尚)', '双喜(软经典)',
    '中南海(典8)', '蒙特二号10支装', '红双喜大喜',
    '高希霸世纪二25支装', '长白山(777)', '黄金叶(乐途)',
    '中南海(京韵细支烤烟)', '钻石(经典纯和)', '钻石(细支尚风)',
    '中南海(典5)', '黄鹤楼(硬15细支)', '黄鹤楼(硬圣火)',
    '双喜(国喜细支)', '钻石(硬蓝)', '钻石(一品荷花)',
    '双喜(大国喜)', '钻石(细支荷花)', '云烟(清甜香)',
    '黄鹤楼(软蓝)', '利群(休闲云端)'
]

# 查
# 列表索引从0开始，程序员都知道
print(tobaccos[0])
print(tobaccos[1])
# 从索引0开始的5-0=5个，不是指向索引5：
print(tobaccos[0:5])
# 从索引2开始的5-2=3个，不是指向索引5：
print(tobaccos[2:5])
print(tobaccos[-1])
# 从第0个到尾：
print(tobaccos[0:])

黄鹤楼(软珍品)
中南海(硬酷爽风尚)
[‘黄鹤楼(软珍品)’, ‘中南海(硬酷爽风尚)’, ‘双喜(软经典)’, ‘中南海(典8)’, ‘蒙特二号10支装’]
[‘双喜(软经典)’, ‘中南海(典8)’, ‘蒙特二号10支装’]
利群(休闲云端)
[‘黄鹤楼(软珍品)’, ‘中南海(硬酷爽风尚)’, ‘双喜(软经典)’, ‘中南海(典8)’, ‘蒙特二号10支装’, ‘红双喜大喜’, ‘高希霸世纪二25支装’, ‘长白山(777)’, ‘黄金叶(乐途)’, ‘中南海(京韵细支烤烟)’, ‘钻石(经典纯和)’, ‘钻石(细支尚风)’, ‘中南海(典5)’, ‘黄鹤楼(硬15细支)’, ‘黄鹤楼(硬圣火)’, ‘双喜(国喜细支)’, ‘钻石(硬蓝)’, ‘钻石(一品荷花)’, ‘双喜(大国喜)’, ‘钻石(细支荷花)’, ‘云烟(清甜香)’, ‘黄鹤楼(软蓝)’, ‘利群(休闲云端)’]

改

1
2
tobaccos[-1] = '吸烟有害健康'
print(tobaccos[-1])

吸烟有害健康

删

1
2
3
4
5
# 按索引删
del tobaccos[0]
# 直接删除,判断一下元素是否在列表中
if '蒙特二号10支装' in tobaccos:
    tobaccos.remove('蒙特二号10支装')

增

1
2
3
4
5
6
# 指定索引位置插入
tobaccos.insert(0, '中华(硬)')
# 在末尾新增
tobaccos.append('玉溪(软)')
print(tobaccos[0:5])
print(tobaccos[-1])

[‘中华(硬)’, ‘中南海(硬酷爽风尚)’, ‘双喜(软经典)’, ‘中南海(典8)’, ‘红双喜大喜’]
玉溪(软)

对列表的常用操作

1
2
3
4
5
6
7
8
9
10
11
12
print(len(tobaccos))
print(tobaccos.index('利群(休闲云端)'))
# 反向元素，后变前，前变后
# 这里直接打印为什么返回None?
print(tobaccos.reverse())
print(tobaccos)
# 移除最后一个元素并返回它
print(tobaccos.pop())
print(len(tobaccos))
# 清空列表
tobaccos.clear()
print(tobaccos)

23
22
None
[‘利群(休闲云端)’, ‘黄鹤楼(软蓝)’, ‘云烟(清甜香)’, ‘钻石(细支荷花)’, ‘双喜(大国喜)’, ‘钻石(一品荷花)’, ‘钻石(硬蓝)’, ‘双喜(国喜细支)’, ‘黄鹤楼(硬圣火)’, ‘黄鹤楼(硬15细支)’, ‘中南海(典5)’, ‘钻石(细支尚风)’, ‘钻石(经典纯和)’, ‘中南海(京韵细支烤烟)’, ‘黄金叶(乐途)’, ‘长白山(777)’, ‘高希霸世纪二25支装’, ‘红双喜大喜’, ‘蒙特二号10支装’, ‘中南海(典8)’, ‘双喜(软经典)’, ‘中南海(硬酷爽风尚)’, ‘黄鹤楼(软珍品)’]
黄鹤楼(软珍品)
22
[]

元组

元组tuple用()表示

1
2
3
4
tobaccos = (
    '黄鹤楼(软珍品)', '中南海(硬酷爽风尚)', '双喜(软经典)',
    '中南海(典8)', '蒙特二号10支装', '红双喜大喜',
)

查

1
2
3
4
print(tobaccos[0])
print(tobaccos[1:5])
print(tobaccos[-1])
print(tobaccos[0:])

黄鹤楼(软珍品)
(‘中南海(硬酷爽风尚)’, ‘双喜(软经典)’, ‘中南海(典8)’, ‘蒙特二号10支装’)
红双喜大喜
(‘黄鹤楼(软珍品)’, ‘中南海(硬酷爽风尚)’, ‘双喜(软经典)’, ‘中南海(典8)’, ‘蒙特二号10支装’, ‘红双喜大喜’)

改

元组不可变，不能如列表这样随意更改

1
tobaccos[0] = '中华'

TypeError: ‘tuple’ object does not support item assignment

删

也不能像列表那样删除

1
del tobaccos[0]

TypeError: ‘tuple’ object doesn’t support item deletion

但可以删除整个元组渣都不剩！

1
del tobaccos

增

元组也不具备列表insert、append两个增加方法
如硬要增加只能这样再搞个元组 + 合并进去,注意那个逗号,

1
2
newtuple = ('中华',) + tobaccos
print(newtuple)

(‘中华’, ‘黄鹤楼(软珍品)’, ‘中南海(硬酷爽风尚)’,
‘双喜(软经典)’, ‘中南海(典8)’, ‘蒙特二号10支装’, ‘红双喜大喜’)

列表与元组怎样选择，怎样转换

列表和元组里面都可以任意存储不同类型的数据
int、float、string杂食不会消化不良
列表主要用来存储经常需要变动的数据
元组可存储：坐标数据，地理位置的经纬度等不会变化的数据

1
2
3
4
5
6
7
8
my_list = [('中华(硬)', 381.6, 450)]

# 查看内存占用情况，使用 __sizeof__() 来获取
print(my_list.__sizeof__())
# 增加元素后内存占用由24增加为40
my_list.append(('天子(软黄)', 392.2, 450))
print(my_list)
print(my_list.__sizeof__())

24
[(‘中华(硬)’, 381.6, 450), (‘天子(软黄)’, 392.2, 450)]
40

1
2
3
4
5
my_list = [1, 2, 3, 4, 5]
my_tuple = tuple(my_list)
print(my_tuple)
my_list = list(my_tuple)
print(my_list)

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

字典

字典里面的元素是由 key : value 键值对组成
键key不可重复

1
tobaccos = {'品名': '中华(硬)', '批发价': 381.6,}

查

1
2
3
print(tobaccos)
print(tobaccos['品名'])
print(tobaccos['批发价'])

{‘品名’: ‘中华(硬)’, ‘批发价’: 381.6}
中华(硬)
381.6

改

1
2
3
tobaccos['品名'] = '中华(软)'
tobaccos['批发价'] = 583
print(tobaccos)

{‘品名’: ‘中华(软)’, ‘批发价’: 583}

删

指定键key删除

1
2
del tobaccos['批发价']
print(tobaccos)

{‘品名’: ‘中华(软)’}
清空字典：

1
tobaccos.clear()

删除字典：

1
del tobaccos

增

1
2
3
# 增
tobaccos['焦油量'] = 11.0
print(tobaccos)

{‘品名’: ‘中华(软)’, ‘批发价’: 583, ‘焦油量’: 11.0}

字典和列表以及元组之间的转换

1
2
3
4
print(tobaccos.keys())
print(tobaccos.values())
# 将字典中的键值对分别转换成一个一个的元组，再由这些元组组成列表
print(tobaccos.items())

dict_keys([‘品名’, ‘批发价’, ‘焦油量’])
dict_values([‘中华(软)’, 583, 11.0])
dict_items([(‘品名’, ‘中华(软)’), (‘批发价’, 583), (‘焦油量’, 11.0)])

集合

集合set本质是一种hash，具有唯一、无序、不可重复性
虽然也用花括号表示，但没有字典的键值对概念，就是个集合而也

1
2
3
4
5
6
7
a = {1, 2, 3}
# 元组转集合
b = set((1, 2, 3, 4, 5))
print(b)
# 列表转集合
b = set([1, 2, 3, 4, 5])
print(b)

{1, 2, 3, 4, 5}
{1, 2, 3, 4, 5}

1
2
3
# 自动去重值
c = {1, 1, 1, 2, 2, 2, 3, 3, 3}
print(c)

{1, 2, 3}

查

判断元素在不在集合中

1
2
3
4
a = {1, 2, 3}
print(1 in a)
print(4 in a)
print(4 not in a)

True
False
True

增 add方法

set可以存放字符串，数字和元组，不能存放列表[]

1
2
3
4
5
6
7
8
a.add(4)
print(a)
a.add((5, 6, 7))
print(a)
a.add('数学概念集合')
print(a)
# 不能增加列表
# a.add([8, 9])

{1, 2, 3, 4}
{1, 2, 3, 4, (5, 6, 7)}
{1, 2, 3, 4, (5, 6, 7), ‘数学概念集合’}

追加update

可传入列表、元组、集合追加
这比add方法好用啊
可以看到其中追加的字符串的打印结果是无序状态

1
2
3
4
5
a = {1, 2, 3}
a.update([4, 5, '列表'])
a.update((6, 7, '元组'))
a.update({8, 9, '集合'})
print(a)

{1, 2, 3, 4, 5, ‘列表’, 6, 7, 8, 9, ‘元组’, ‘集合’}

删

remove方法：元素不存在要报错
discard方法：即使元素不存在也不报错

1
2
3
4
5
6
7
8
a = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 'test'}
a.remove('test')
print(a)
a.discard(10)
a.discard(10)
print(a)
a.clear()
print(a)

{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
{1, 2, 3, 4, 5, 6, 7, 8, 9}
set()

并集交集子集父集

1
2
3
4
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a.union(b))
print(a.intersection(b))

{1, 2, 3, 4, 5, 6}
{3, 4}

1
2
3
4
5
6
c = {7, 8}
d = {7, 8, 9, 10}
# 判断c集合是否为d集合的子集
print(c.issubset(d))
# 判断d集合是否为c集合的父集
print(d.issuperset(c))

True
True