Python学习笔记

Python基本数据类型

Number:数字

整数、小数
整数：int
浮点数：float

/（单斜杠）是除法，会自动转型成浮点数类型
//（双斜杠）是整除，只保留整数部分

各进制的表示与转换

二进制表示
用0b做前缀表示二进制，
用0o做前缀表示八进制，
用0x做前缀表示十六进制，

二进制的转换，用
bin()
可以实现任意进制的数向二进制的转化
八进制的转换，用
oct()
可以实现任意进制的数向八进制的转化
十进制的转换，用
int()
可以实现任意进制的数向十进制的转化
十六进制的转换，用
hex()
可以实现任意进制的数向十六进制的转化

bool布尔类型：表示真、假
非0表示布尔的真，只有0表示布尔的假。
complex:复数

str 字符串

如何表示字符串？
单引号、双引号、三引号（解决回车换行问题（三个单引号，或者三个双引号））

转义字符

特殊的字符–》表示无法看到的字符、与语言本身语法有冲突的字符
注：一个字符串之前加上r，表示不是一个普通字符串，而是一个原始字符串

字符串的运算

字符的截取(序号)

>>> 'hello world'[-5]
'w'
>>> 'hello world'[6]
'w'

字符串的截取(切片)

>>> 'hello world'[0:5]
'hello'
>>> 'hello world'[6:]
'world'
>>> 'hello world'[-5:]
'world'

‘组’的概念与定义(序列)

列表list: [1,2,3,str,true]
嵌套列表，也就是二维列表: [[],[],[]]
元组，tuple: (1,2,3)
注：访问组的元素和访问字符串的操作一样

判断某个元素是否在序列中： in

>>> 3 in [1,2,3,4]
True

判断某个元素是否不在序列中： not in

>>> 3 not in [1,2,3,4]
False

关于序列的函数:

len()
max()
min()

查看字符的ascll码：ord()

>>> ord(' ')
32
>>> ord('w')
119

set集合: {1，2，3}

无序，不支持序号索引

>>> type({1,2,3})

定义空的集合：

>>> type(set())

求两个集合的差集

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

求两个集合的交集

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

求两个集合的并集

>>> {1,2,3,4,5,6} | {3,4,7}
{1, 2, 3, 4, 5, 6, 7}

字典 dict: 很多的key和value。字典不允许有重复的key。

{key1:value1, key2:value2}
>>> {"Q" : "新月打击","W" : "苍白之瀑","E" : "月之降临","R" : "月神冲刺"}
{'Q': '新月打击', 'W': '苍白之瀑', 'E': '月之降临', 'R': '月神冲刺'}

通过key得到/访问value。

>>> {"Q" : "新月打击","W" : "苍白之瀑","E" : "月之降临","R" : "月神冲刺"}['Q']
'新月打击'
>>> {"Q" : "新月打击","W" : "苍白之瀑","E" : "月之降临","R" : "月神冲刺"}['R']
'月神冲刺'

key:必须是不可变的类型–>int,’str’
value:可以取Python里面的任意类型。

Python基本语法

变量与运算符

变量: 名字
定义一个变量：Python的变量不需要定义
注：变量命名的规则，可读性要强。变量由字母、数字、下划线组成。且首字母不能为下划线。系统关键字，不能用在变量名中，即保留关键字。区分大小写。动态语言。

   >>> A = [1,2,3,4,5,6]
   >>> print(A)
   [1, 2, 3, 4, 5, 6]
   >>> B = [1,2,3]
   >>> A*3+B+A

[1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 4, 5, 6, 1, 2, 3, 1, 2, 3, 4, 5, 6]

int str tuple：值类型、不可改变
list set dict ：引用类型、可改变

列表的可变与元组的不可变
Python运算符
python运算符的优先级
算数运算符–>加、减、乘、除、取余。
注：2**3表示2的3次方（双乘号）

>>> 2**3
8

赋值运算符 ：
=、 +=、 *=
Python中没有自增、自减运算符–>c++、 c–
比较（关系）运算符
==、 !=、 >、 <、 >=、 <=
逻辑运算符
and（且）、 or（或）、 not（非）
成员运算符
in、 not in
身份运算符 is、 not is
如果两个变量取值相等，则is返回True。
is和==的区别
==：比较值是否相等
is：不是比较值相等，比较的是两个变量的身份（内存地址）是否相等。
类型的判断：isinstance

>>> a='hello'
>>> isinstance(a,str)
True
>>> isinstance(a,(str,int))
True
>>> isinstance(a,(float,int))
False

注：对象的三个特征：
id、value、type
位运算符： 把数字当作二进制数进行运算

& 按位与
| 按位或

条件控制

    flag = True
    if flag:
        print("Hello Python")
    else:
        print("Error")

一个例子

    USERNAME = "admin"
    PASSWORD = "123456"
    print("please input username:")
    name = input()
    print("please input password:")
    word = input()
    flag = (name == USERNAME) and (word == PASSWORD)

    if flag:
        print("SUCCESS")
    else:
        print("FAIL")


    if TRUE:
    pass#占位语句、空语句

if … elif … elif不能单独使用

    a = input()
    if a == '1':
        print('A')
    elif a == '2':
        print('B')
    elif a == '3':
        print('C')
    else:
        print('D')

循环控制

while与while…else
for与for…else：主要是用来遍历循环 序列或者集合字典

    a = [['AA', 'BB', 'CC', 'DD'], (1, 2, 3)]
    for x in a:
        for y in x:
            print(y, end=' ')

    AA BB CC DD 1 2 3

    for x in range(0, 10, 2):
        print(x, end=' | ')

    0 | 2 | 4 | 6 | 8 | 

    for x in range(10, 0, -2):
        print(x, end=' | ')

    10 | 8 | 6 | 4 | 2 | 

break语句 （强行结束循环）
break语句作用：
1、可以用来从循环体内跳出循环体，即提前结束循环，接着执行循环下面的语句。
2、使流程跳出switch结构
注意:break语句不能用于循环语句和switch语句之外的任何其他语句中 。

continue语句作用：
结束本次循环，即忽略循环体中continue语句下面尚未执行的语句，接着进行下一次是否执行循环的判定。

注意:continue语句不能用于循环语句之外的任何其他语句中 。

continue语句和break语句的区别：
continue语句只结束本次循环，而不是终止整个循环的执行。
break语句则是结束整个循环过程，不再判断执行循环的条件是否成立。break语句可以用在循环语句和switch语句中。在循环语句中用来结束内部循环；在switch语句中用来跳出switch语句。
注意:循环嵌套时，break和continue只影响包含它们的最内层循环，与外层循环无关。

包与模块

代码块之间无括号，用代码对齐表示代码块

import…
from…import…
包和模块是不能被重复导入的
避免循环导入
Python里面文件夹与包的区分是因为包下面包含init.py 文件

Python函数

1.功能性
2.隐藏细节
3.避免编写重复的代码

print()

保留两位小数

a = 1.2345
result = round(a, 2)
print(result)

自定义函数

def add(x, y):
    result = x + y
    return result

return可以返回多个值，实际返回一个元组（tuple）

    def damage(skill1, skill2):
    skill1 += 100
    skill2 *= 10
    return skill1, skill2


    damage_skill1, damage_skill2 = damage(20, 30)
    #序列解包
    print(damage_skill1, damage_skill2)

序列解包
元素的个数要相等
参数
1.必需参数
2.关键字参数

add(y=3,x=2)

3.默认参数
定义函数的时候直接在形参之中赋值

注：必须参数必须全部放在前面，默认参数必须全部放在后面

 def add(x, y=2):
    result = x + y
    return result

Python面向对象的思想

类与对象

class

类的定义：

    class Student():
    name = ''
    age = 0

    def print_file(self):
         print('name = ' + self.name)
         print('age = '+str(self.age))

注意：类里面的函数一定要加self，且调用函数变量也是通过self。

类的实例化：

student = Student()

注意： Python没有new关键字，直接使用类名加括号的方式完成；类的实例化。

类的引用：

from test4 import Student

构造函数

类变量与实例变量

print(Student.name)，通过类名.类变量访问实例变量。

    class Student():
        #类变量
        name = '小七'
        age = 0

        # 构造函数
        # 初始化对象的属性
        def __init__(self, name, age):
            #构造函数变量
            self.name = name
            self.age = age
            print("Student")

        def do_homework(self):
            print('name = ' + self.name)
            print('age = ' + str(self.age))
            print('do homework!')


    #实例变量        
    student = Student('李小璐', 18)
    print(student.__dict__)
    student.do_homework()

{‘name’: ‘李小璐’, ‘age’: 18}
name = 李小璐
age = 18
do homework!

self与实例方法

1. self几乎相当于this。
2. 显示指出，显胜于隐。
3. 实例方法的特点：第一个参数要传入self。

类方法

通过注解（装饰器）的方式声明类方法：@classmethod

@classmethod
def plus_sum(cls):
    pass

静态方法

通过注解（装饰器）的方式声明静态方法：@staticmethod

@staticmethod
def add(x, y):
    pass

成员的可见性

使用global关键字定义全局变量
加上双下划线就可吧成员变为私有的，相当于private。Python内部实际上是将定义的私有变量改了名称，变相的私有化。

     __score = 60
     def __add(x, y):
        pass

通过print(student.dict)看一下：
{‘name’: ‘李小璐’, ‘age’: 18, ‘_Student__score’: 100}
可知我们定义的“__score”变量被系统更名为“_Student__score”，这时我们访问_Student__score是可以访问的到的。、
整个类的结构如下：

    class Student():
        name = '小七'
        age = 0
        __score = 60

        # 构造函数
        # 初始化对象的属性
        def __init__(self, name, age):
            self.name = name
            self.age = age
            print("Student")

        def set_score(self, score):
            self.__score = score

        def get_score(self):
            return self.__score

        def do_homework(self):
            print('name = ' + self.name)
            print('age = ' + str(self.age))
            print('do homework!')

        @classmethod
        def plus_sum(cls):
            pass

        @staticmethod
        def add(x, y):
            pass


    student = Student('李小璐', 18)
    print(Student.name)
    student.do_homework()
    student.set_score(100)
    print(student.get_score())
    print(student.__dict__)
    print(Student._Student__score)

Student
小七
name = 李小璐
age = 18
do homework!
100
{‘name’: ‘李小璐’, ‘age’: 18, ‘_Student__score’: 100}
60

继承

避免定义重复的方法，重复的对象

    class Animal():
        speak = ''

        def __init__(self, speak):
            self.speak = speak

        def get_speak(self):
            return self.speak

        def eat(self):
            print('Animal eat')


    class Cat(Animal):
        name = ''

        def __init__(self, name, speak):
            super(Cat, self).__init__(speak)
            self.name = name

        def get_name(self):
            return self.name

        def eat(self):
            super(Cat, self).eat()
            print('Cat eat')


    cat = Cat('花花', '喵喵喵')
    print(cat.get_name() + '正在说：' + cat.get_speak())
    cat.eat()

花花正在说：喵喵喵
Animal eat
Cat eat

Car继承了Animal，用super关键字，可以调用父类的构造方法，也可以调用父类的实例方法。

正则表达式（regular expression）

正则表达式介绍

正则表达式是一个特殊的字符序列，一个字符串是否与我们这样的字符序列相匹配。
快速检索文本，实现文本的替换操作
1. 检查一串数字是否是电话号码
2. 检查一个字符串是否符合email标准
3. 把一个文本里面指定的单词替换为另一个单词

引入re模块

import re

例如，找出字符串中的所有数字

    import re

    a = 'w3e45rb6gh6j87'
    r = re.findall('\d', a)
    print(r)

[‘3’, ‘4’, ‘5’, ‘6’, ‘6’, ‘8’, ‘7’]

元字符’\d’匹配一个数字字符，

字符集

import re

    a = 'abc, acc, adc, aec, afc, ahc'
    # 中括号内的字符是或关系，a[bf]c相当于abc,afc
    r = re.findall('a[bf]c', a)
    print(r)
    # 中括号内的字符是或关系，a[b-f]c相当于abc, acc, adc, aec, afc
    r = re.findall('a[b-f]c', a)
    print(r)

[‘abc’, ‘afc’]
[‘abc’, ‘acc’, ‘adc’, ‘aec’, ‘afc’]

概括字符集

\s：用于匹配单个空格符，包括tab键和换行符；
\S：用于匹配除单个空格符之外的所有字符；
\d：用于匹配从0到9的数字；
\D：用于匹配非从0到9的数字；
\w：用于匹配字母，数字或下划线字符；[A-Za-z0-9_]
\W：用于匹配所有与\w不匹配的字符；
. ：用于匹配除换行符之外的所有字符。
链接如下：
https://baike.baidu.com/item/%E6%AD%A3%E5%88%99%E8%A1%A8%E8%BE%BE%E5%BC%8F

数量词

在表达式后面加个大括号{}

  import re

    a = 'python10java123php12c'
    # [a-z]{3}匹配a-z的字符。每三个为一组
    # 最小为3，最大为6
    # 贪婪与非贪婪,Python默认贪婪的模式尽可能的匹配更多
    # '[a-z]{3,6}?' 在后面加个问号，就是非贪婪的模式
    r = re.findall('[a-z]{3,6}', a)
    print(r)

[‘python’, ‘java’, ‘php’]
由于Python默认贪婪的模式，会尽可能的匹配更多，当匹配到’pyt’的时候满足条件，但是由于贪婪还会继续匹配后面的’hon‘，直到不满足条件为止（字符是否在a-z之间，长度是否超过6）.

‘*’星号前面的字符可以匹配0次，甚至n次

‘+’加号前面的字符可以匹配1次，甚至n次

‘？’问号前面的字符可以匹配0次，甚至1次

import re

    a = 'pytho00python11pythonn22'
    r = re.findall('python*', a)
    print(r)
    r = re.findall('python+', a)
    print(r)
    r = re.findall('python?', a)
    print(r)

[‘pytho’, ‘python’, ‘pythonn’]
[‘python’, ‘pythonn’]
[‘pytho’, ‘python’, ‘python’]
结果第三行，第三个单词怎么会出现python呢，？不是匹配0次n，或者1次n吗。原因是将pythonn后面的一个n截取了，在匹配pythonn时匹配到python的时候，满足条件，就自动输出了，没有理会后面的n。

边界匹配符

匹配一个QQ号是否是4-8位的

shift+6 ^(从字符串的开头开始匹配)
shift+4 $(从字符串的末尾开始匹配)

    qq = '123456789'
    print(re.findall('^\d{4,8}$', qq))

组 ：一个括号就是一个组

查看一个字符串中是否包含5个Python

 st = 'PythonPythonPythonPythonPythonPythonPython'
    print(re.findall('PythonPythonPythonPythonPython', st))
    print(re.findall('(Python){5}', st))

匹配模式参数

如，忽略大小写 re.I、re.S
用findall()的第三个参数

 a = 'ABC'
    r = re.findall('abc', a, re.I)
    print(r)
    r = re.findall('abc', a, re.I | re.S)
    print(r)

re.sub正则替换

  a = 'PythonC#PHP'
    r = re.sub('C#', 'Java', a, 1)
    print(r)

PythonJavaPHP
将字符串a中的C#替换为Java,且只替换1次，要是改为0（默认），则无限替换。可以用一个函数替换Java做为参数。

把函数作为参数传递

找出字符串‘A8C3721D86’中的数字，将小于6的替换为0，大于6的替换为9。

import re

    s = 'A8C3721D86'


    def convert(value):
        matched = value.group()
        if int(matched) < 6:
            return str(0)
        else:
            return str(9)


    r = re.sub('\d', convert, s)
    print(r)

A9C0900D99

search与match函数

re.match()
re.search()

group()分组

  s = 'life is short, i use python, i love python'

    r = re.search('life(.*)python(.*)python', s)
    print(r.group(0, 1, 2))
    print(r.groups())

(‘life is short, i use python, i love python’, ’ is short, i use ‘, ‘, i love ‘)
(’ is short, i use ‘, ‘, i love ‘)
group(0)对应的是整个字符串的完整的匹配项
group(1)对应的是第一个分组
group(2)对应的是第二个分组

groups()返回的是第一个与第二个分组

常用的正则表达式：

https://www.cnblogs.com/Akeke/p/6649589.html

JSON

一种轻量级的数据交换格式，跨语言交换数据

字符串是json的表现形式

符合JSON格式的字符串，叫做JSON字符串

反序列化

导入json模块

import json

  import json

    json_str = '{"status": 0, "msg": "登录成功", "data":{"id": 1,"username": "admin"}}'
    data = json.loads(json_str)
    print(type(data))
    print(data)

class ‘dict’
{‘status’: 0, ‘msg’: ‘登录成功’, ‘data’: {‘id’: 1, ‘username’: ‘admin’}}
可以看到Python的json.loads(json_str)函数，将json字符串转换成了字典（dict）类型

JSON数据类型所对应的Python的数据类型如下：

序列化

JSON、JSON对象与JSON字符串
JSON是一种轻量级的数据交换格式，跨语言交换数据。

符合JSON格式的字符串，叫做JSON字符串，字符串是json的表现形式。

JSON对象是相对于js来说的。概念太模糊，大概把JSON解析出来的数据封装成的对象就成为JSON对象吧。

Python的高级语法与用法

枚举其实是一个类

从枚举模块导入枚举类（Enum或IntEnum）
from enum import Enum

 from enum import Enum

    class VIP(Enum):
    RED = 1
    YELLOW = 2
    GREEN = 3


    print(VIP.YELLOW)
    print(VIP.YELLOW.value)
    print(VIP.YELLOW.name)

    for v in VIP:
        print(v)

VIP.YELLOW
2
YELLOW
VIP.RED
VIP.YELLOW
VIP.GREEN

所有枚举类型，都是Enum的子类。

枚举类型、枚举的名字、枚举的值

枚举的比较
不可以做大小比较，但是可以做等值（身份）的比较。

遍历有别名的枚举：

   class VIP(Enum):
    RED = 1
    YELLOW = 2
    YELLOW_ALIAS = 2
    GREEN = 3


    for v in VIP.__members__.items():
        print(v)

('RED', )
('YELLOW', )
('YELLOW_ALIAS', )
('GREEN', )

枚举转换

a = 2
print(VIP(a))

VIP.YELLOW

Python进阶

函数式编程

闭包

在其他语言里面，如Java函数只是一段可执行的代码，并不是对象。在Python里面一切皆对象。
在Python里面可以把一个函数作为参数传递给第一个函数，也可以报函数作为另一个函数的返回结果。

闭包 = 函数+环境变量
一个例子

  def curve_pre():
    a = 25

    def curve(x):
        return a * x * x
    return curve

    # a = 10            
    f = curve_pre()
    print(f(2))

可以看到结果是100，在curve_pre()中return curve的同时不仅把curve(x)函数返回，而且把curve(x)函数的闭包也返回，所以在外部更改a的值，结果不变。

 origin = 0


    def factory(pos):
        def go(step):
            nonlocal pos
            new_pos = pos + step
            pos = new_pos
            return new_pos
        return go


    tourist = factory(origin)
    print(tourist(2))
    print(tourist(3))
    print(tourist(6))

2
5
11

nonlocal关键字标明了pos不是局部变量。

匿名函数

使用关键字lambda 定义匿名函数。
lambda 参数: 表达式

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


    print(add(1, 2))

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

3
3

注：三元表达式。
1. 其他语言（java, c）
x > y ? x : y
2. Python
条件为真的时候返回的结果 if 条件判断 else 条件为假时的返回结果

map

map方法
map(方法，序列)
对传入的序列的每一个对象，都执行方法。

map与lambda

list_x = [1, 2, 3, 4, 5, 6]
    r = map(lambda x:x*x, list_x)
    print(list(r))

[1, 4, 9, 16, 25, 36]

reduce

reduce连续计算，连续执行表达式，将序列中的元素逐个取出，执行函数操作。
引入reduce模块
from functools import reduce

from functools import reduce

    list_x = [1, 2, 3, 4, 5, 6]
    r = reduce(lambda x, y: x + y, list_x)
    print(r)

21

实际就是对list_x序列求和，如果把lambda x, y: x + y改为lambda x, y: x * y，则对listx序列求积

filter

过滤
例：过滤掉一个数列中大于50的数

  list_x = [10, 45, 54, 22, 53, 63]
    r = filter(lambda x: True if x < 50 else False, list_x)
    print(list(r))

[10, 45, 22]
注：filter()接收的第一个参数的函数返回值为bool类型。

装饰器

感觉类似于java的注解
修改项目业务功能的时候，对修改是封闭的，对扩展是开放的。

*args表示可以接受任意多个参数。
**kw可以接受任意多个关键字参数。

 import time


    def decorator(func):
        def wrapper(*args, **wk):
            print(time.time())
            func(*args, **wk)
        return wrapper


    @decorator
    def f1(func_name):
        print('This is f1' + func_name)


    @decorator
    def f2(func_name1, func_name2):
        print('This is f2' + func_name1)
        print('This is f2' + func_name2)


    @decorator
    def f3(func_name1, func_name2, **kw):
        print('This is f3' + func_name1)
        print('This is f3' + func_name2)
        print(kw)


    f1('test')
    f2('test1', 'test2')
    f3('test1', 'test2', a=1, b=2, c='kw')

1517129065.1393104
This is f1test
1517129065.1393104
This is f2test1
This is f2test2
1517129065.1393104
This is f3test1
This is f3test2
{‘a’: 1, ‘b’: 2, ‘c’: ‘kw’}

实战：原生简单爬虫

本质：对html文件进行分析，从而从文本中提取出有用的信息。
爬取斗鱼直播LOL模块下的主播名称及其人气。

from urllib import request
import re


class Spider():

    url = 'https://www.douyu.com/directory/game/LOL'
    # url = 'https://www.panda.tv/cate/lol'
    # 非贪婪模式
    root_pattern = '([\s\S]*?)
'
    name_pattern = '([\s\S]*?)'
    number_pattern = ''

    def __fetch_content(self):
        # 如果不加上下面的这行出现会出现urllib2.HTTPError: HTTP Error 403: Forbidden错误
        # 主要是由于该网站禁止爬虫导致的，可以在请求加上头信息，伪装成浏览器访问User-Agent,
        # 具体的信息可以通过火狐的FireBug插件查询
        headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:23.0) Gecko/20100101 Firefox/23.0'}
        req = request.Request(url=Spider.url, headers=headers)
        r = request.urlopen(req)
        # bytes
        htmls = r.read()
        htmls = str(htmls, encoding='utf_8')

        return htmls

    def __analysis(self, htmls):
        root_htmls = re.findall(Spider.root_pattern, htmls)
        anchors = []
        for html in root_htmls:
            name = re.findall(Spider.name_pattern, html)
            number = re.findall(Spider.number_pattern, html)
            anchor = {'name': name, 'number': number}
            anchors.append(anchor)
        # print(anchors[0])

        return anchors

    def __refine(self, anchors):
        l = lambda anchor: {
            'name': anchor['name'][0].strip(),
            'number': anchor['number'][0].strip()[1:]
        }

        return map(l, anchors)

    def __soft(self, anchors):
        # Python内置排序函数
        anchors = sorted(anchors, key=self.__sort_seed, reverse=True)

        return anchors

    def __sort_seed(self, anchor):
        r = re.findall('\d*',anchor['number'])
        number = float(r[0])
        if '万' in anchor['number']:
            number *= 10000

        return number

    def __show(self, anchors):
        for rank in range(0, len(anchors)):
            print('rank: ' + str(rank+1) + ' name: ' + anchors[rank]['name'] + ' number: ' + anchors[rank]['number'])
        # for anchor in anchors:
        #     print(anchor['name']+'----'+anchor['number'])

    def go(self):
        htmls = self.__fetch_content()
        anchors = self.__analysis(htmls)
        anchors = list(self.__refine(anchors))
        anchors = self.__soft(anchors)
        self.__show(anchors)


spider = Spider()
spider.go()

rank: 1 name: 英雄联盟官方赛事 number: 90.8万
rank: 2 name: 叫我久哥哥 number: 60.9万
rank: 3 name: 英雄联盟官方赛事二 number: 59.5万
rank: 4 name: 洞主丨歌神洞庭湖 number: 44.5万
rank: 5 name: 誓约中二约 number: 17.3万
rank: 6 name: 叶音符 number: 16.7万
rank: 7 name: 仙凡哥哥丶 number: 11.4万
rank: 8 name: 思思娜 number: 9.9万
rank: 9 name: 黑白锐雯 number: 9.4万
rank: 10 name: LoveAcFun包子 number: 8.1万

Python杂记

字典代替switch

'''字典代替switch'''

day = 6
switcher = {
    0: 'Sun',
    1: 'Mon',
    2: 'Tue'
}

# day_name = switcher[day]
day_name = switcher.get(day, 'UnKnow')
print(day_name)

集合推导式

a = [1, 2, 3, 4, 5]
b = [i**3 for i in a if i >= 3]
print(b)
b = {i**3 for i in a if i >= 3}
print(b)

[27, 64, 125]
{64, 27, 125}

switcher = {
    0: 'Sun',
    1: 'Mon',
    2: 'Tue'
}

b = {value:key for key, value in switcher.items()}
print(b)

{‘Sun’: 0, ‘Mon’: 1, ‘Tue’: 2}

Test对象的布尔取值

class Test():
    def __len__(self):
        return 0

    def __bool__(self):
        return False

# 这两个方法将影响Test对象的布尔取值。
#__bool__大于__len__
test = Test()

print(bool(test))