#全部行都能输出

from IPython.core.interactiveshell import InteractiveShell

InteractiveShell.ast_node_interactivity = "all"

1.Python注释

# 文档字符串是Python独特的注释方式。是包，模块，类或函数的第一条语句。通过 “函数名._ doc _” 获得。

# 用三个单引号或双引号。

def Avg(score, Num = 100):

'''计算班级的平均分

从score读取所有学生成绩的列表

Num：班级总人数, 默认值为100

返回值：

float 类型的平均分

'''

pass # pass 不做任何事情，一般用作占位语句

# 查看文档注释

print(Avg.__doc__) # 查看文档注释

help(Avg) # 查看函数帮助，获取文档注释

2. 查看关键字和保留字

import keyword

keyword.kwlist

3. 标准数据类型

布尔值(Booleans)：True或False；

数字(Number)：整数、浮点数、分数、复数；

字符串(Strings)：Unicode字符序列；

列表(Lists)：有序的值的序列；

元组(Tuples)：有序的值的不可变序列；

集合(Sets)：无序的值的集合；

字典(Dictionaries)：无序的键-值对的集合

4. type(obj) 返回obj的类型

5.布尔运算(and, or, not)

True and False # False

0 or [] # []

True or False # True

not True # False

1 == 1.0 # True

True + False # 结果为1 True 与 1 一一对应， False 与 0 一一对应

6. 分数

# 需要注意的是，Python会自动进行约分

import fractions #要使用分数，必须引入的一个模块

x = fractions.Fraction(1, 2)

y = fractions.Fraction(0.25)

print(x) # 1/2

print(y) # 1/4

7. 复数 complex：

复数对象有两个属性real和imag用于查看实部和虚部。

语法：real + imagj 虚数不能单独存在，它们总是和一个值为0.0的实数部分一起构成一个复数；

实数部分和虚数部分都是浮点数。虚数部分必须有 j 或 J

num.real:返回该复数的实数部分

num.imag:返回该复数的虚数部分

num.conjugat():返回该复数的共轭复数

complex(real,imag):其中，real可以为int、float或字符串类型；而imag只能为int或float类型。

8. 数字之间的转换

奇进偶舍 整数位为奇数进一位，整数位为偶数舍

round(4.5) # 4

round(3.5) # 4

round(10.5) # 10

round(13.5) # 14

9. 表达式和运算符

# 表达式是由一个或多个操作数及零个或运算符组成的序列，其计算结果为一个值、对象、方法或命名空间。

# 表达式可以包含文本值、方法调用、运算符以及其操作数、或简单名称。简单名称可以是变量名、类型成员

# 名、方法参数名、命名空间或类型名。

# 表达式可以使用运算符(运算符又可以使用其他表达式作为参数)或方法调用(方法调用的参数又可以是其他

# 方法参数)，因此表达式可以很简单，也可以非常复杂

# 运算符类型有算数运算符、关系运算符、赋值运算符、逻辑运算符和条件运算符。

# 按照运算需要的操作数目，可以分为一元，二元，三元运算符：

# 一元：就是只需要一个操作数。例：+，-

# 二元：需要两个操作数。大多数都是二元。

# 三元：需要三个操作数，条件运算是三元运算符。例：b if a else c

(1). 算术运算符是一个二元运算符：只要有任意一个操作数是浮点数，结果就会是浮点数

# + - * /

# // 整除、 ** 乘方(幂)、% 取模(取余)

(2). 关系运算符 ：用于比较两个表达式的值

# == 、 != 、 > 、 < 、 >= 、 <=

(3). 赋值运算符

# = += -= *= /= %= **= //=

# 序列赋值

x, y, z = '1', '2', '3' # 右边是元组的一种写法，x=1,y=2,c=3

x, y, z # ('1', '2', '3')

x, y, z = '123'

x, y, z # ('1', '2', '3')

# x, y, z = '1234' # 报错，参数太多

# x, y, z = '1', '2', '3', '4' # 报错，参数太多

(4). 逻辑运算符

# 对于逻辑 “与”，“或”，“非”，我们使用and，or，not这几个关键字。

# 逻辑运算符and和or也称作短路运算符：它们的参数从左向右解析，一旦结果可以确定就停止。例如，如果A和C为真

# 而B为假，A and B and C不会解析C。在作用于一个普通的非逻辑值时，短路运算符的返回值通常是能够最先确定结

# 果的那个操作数。

# 关系运算可以通过逻辑运算符and和or组合，比较的结果可以用not来取反意。逻辑运算符的优先级又低于关系运算

# 符，在它们之中，not具有最高的优先级，or优先级最低，所以 A and not B or C 等于 (A and (not B)) or C 。

5 and 4 # 4

0 and 4 # 0

False or 3 or 0 # 3

2 > 1 and not 3 > 5 or 4 # True

not 3 > 5 # True

# 运算符优先级由高到低：索引运算符 X[index] -> 幂运算(**) -> 正负号(+ 或 -)

# -> 算术操作符 (* / // + -) -> 比较运算符 (== != > < >= <= ) -> 逻辑运算符 ( and or not )

10. 组合数据类型

# 列表list，元组tuple，字典dict，集合set

# 1. 序列

# (1) 不可变序列 ： tuple, str

# (2) 可变序列 ： list

# 2. 集合 set

# 集合对象是一个由互不相同的hashable对象组成的无序集合。

# set可变，frozenset不可变

# 3. 字典dict

# str的运算符，函数，list和tuple都具备

11. lambda匿名函数

lambda 表示匿名函数，冒号前面的内容表示函数参数、后面的内容为该函数的表达式、返回值就是表达式的结果。

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函

数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数。

func = lambda x: x + 3

func(1) # 4

pairs = [(3, 'three'), (4, 'four'), (1, 'one'), (2, 'two')]

pairs

type(pairs)

#----------------------------------------------------------

[(3, 'three'), (4, 'four'), (1, 'one'), (2, 'two')]

list

#----------------------------------------------------------

pairs.sort(key = lambda pair:pair[0])

pairs

#----------------------------------------------------------

[(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]

#----------------------------------------------------------

pairs.sort(key = lambda pair:pair[1])

pairs

#----------------------------------------------------------

[(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

#----------------------------------------------------------

filter(func,iterable) 遍历序列中的每个元素，判断每个元素得到布尔值，如果是 True 则留下。

a = filter(lambda x: abs(x)>=5,[1, 5, 6, 7, -8, -3, 2, -5, 3])

[*a]

#---------------------------------

[5, 6, 7, -8, -5]

#---------------------------------

def not_empty(s):

return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', ' ']))

#---------------------------------

['A', 'B', 'C']

#---------------------------------

map用法：

map(func,*iterable) 处理序列中的每个元素，得到的结果是一个 map 对象，该可迭代对象中元素的个数及位置与 原来一样。返回的是一个迭代器。

b = map(lambda x: abs(x), [1, 5, 6, 7, 8, -3, -2, -5, 3])

[*b]

#---------------------------------

[1, 5, 6, 7, 8, 3, 2, 5, 3]

#---------------------------------

reversed用法：

reversed(sequence) 生成一个反转序列的迭代器

c = reversed([1, 5, 6, 7, 2, 3, 4])

[*c]

#---------------------------------

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

#---------------------------------

sorted() 用法:

sorted() 对一个集合进行排序, 返回排序后的 list。排序本质是比较大小，所以只能同类型之间比较。

sorted([1, 5, 7, -8, -3, 2, -5, 3], key= abs)

#---------------------------------

[1, 2, -3, 3, 5, -5, 7, -8]

#---------------------------------

L = [("Bob", 75), ("Adam", 92), ("Bart", 66), ("Lisa", 88)]

sorted(L, key = lambda x: x[1])

sorted(L, key = lambda x: x[1], reverse = True)

#----------------------------------------------------------

[('Bart', 66), ('Bob', 75), ('Lisa', 88), ('Adam', 92)]

[('Adam', 92), ('Lisa', 88), ('Bob', 75), ('Bart', 66)]

#----------------------------------------------------------

L = [("Bob", 75), ("Adam", 92), ("Bart", 66), ("Lisa", 88)]

sorted(L, key = lambda x: x[0])

sorted(L, key = lambda x: x[0], reverse = True)

#----------------------------------------------------------

[('Adam', 92), ('Bart', 66), ('Bob', 75), ('Lisa', 88)]

[('Lisa', 88), ('Bob', 75), ('Bart', 66), ('Adam', 92)]

#----------------------------------------------------------

zip() 用法：

zip() 拉链形式，将对象中的多个可迭代序列输出成一一对应的 zip 对象。参数必须是序列，如字符 串、元组、列表

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

#----------------------------------------------------------

#----------------------------------------------------------

list(zip([1, 2, 3], [4, 5, 6]))

#----------------------------------------------------------

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

#----------------------------------------------------------