python入门

简单语法

---

• 退出python交互模式

  exit()

• 输出

  print()

• 输入

  input()

a = 5
b = input('你的输入：')	#输入提示语
print("result",a+b)  	#中间会有空格隔开
print('''1
2
3''')    	#用三个单引号包裹 打印会换行

• 空值

  None

数据类型

---

数值

• 科学计数法

  1.23e9 1.23x10^9

  1.2e-5 0.000012

• 除

  /

• 整除

  //

• 余数

  %

9 / 3   # 3.0
10//3  	# 3 
10%3 	# 1

布尔型

True False

• 或

  or (a or b)

• 且

  and (a and b)

• 非

  not (not a)

字符型

• 转义符

  表示换行， 表示制表符，字符 本身也要转义，所以\表示的字符就是

• r'' 表示不转义

  print(r' ') ' '

• 获取某字符的ASCII值

  ord()

• 获取某ASCII值的字符

  chr()

ord('a')  # 97
chr(97)   # 'a'

• 整数编码（十六进制）

'u4e2du6587'  #'中文'

• bytes 是以字节为单位的数据类型，用于保存和传输，可以节省空间
  bytes类型的数据用带b前缀的单引号或双引号表示

x = b'abc' 
y = b"abc"

字符方法

• 字符型转成bytes

  encode()

• bytes转成字符型

  decode()

'ABC'.encode('ascii')     # b'ABC'
'中文'.encode('utf-8')	# b'xe4xb8xadxe6x96x87'

b'ABC'.decode('ascii') 	  # 'ABC'
b'xe4xb8xadxe6x96x87'.decode('utf-8')  # '中文'

b'xe4xb8xadxff'.decode('utf-8', errors='ignore')  # '中'   小部分无效字节，忽略它

• 获取字符长度

  len() 【 也可获取bytes字节数】

len('ABC')  	# 3
len(b'ABC')  	# 3
len('中文'.encode('utf-8'))  # 6

• 字符格式化

  用 % 占位，用变量填充模板

  %d -- 整数

  %s -- 字符串

  %f -- 浮点数

  %x -- 十六进制整数

用了占位符还想输%，可以用%%来转义

'Hello, %s' % 'world'   #  'Hello, world'
'name: %s,age: %d' % ('李白',32)   # 'name: 李白,age: 32'
'%2d-%02d' % (3, 1)   #  '3-01'
'%.2f' % 3.1415926    #  '3.14'
'growth rate: %d %%' % 7  #'growth rate: 7 %'

format() 第二种格式化方法

'Hello, {0}, 成绩提升了 {1}%'.format('小明', 17.125)  
#'Hello, 小明, 成绩提升了 17.125%'

'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
#'Hello, 小明, 成绩提升了 17.1%'

列表类型

list 是python内置的一种数据类型
list 是一种有序的集合，可以随时添加和删除其中的元素。【也就是数组咯】

创建

students = ['李白','杜甫','白居易']

取值

len(students)  	# 3
students[0]    	# '李白'
students[2]    	# '白居易'

### 可以逆序
students[-1] 	# '白居易'
students[-2] 	# '杜甫'

• 获取list长度

  len(list)

  len(students)	# 3
  

• 添加元素到末尾

  list.append(value)

  students.append('小胖')
  

• 插入元素到指定位置

  list.insert(i,value)

  students.insert(1,'小胖')
  

• 删除list末尾元素

  list.pop()

  students.pop()	# '白居易'
  

• 删除指定位置元素

  list.pop(i)

  students.pop(1)	# '杜甫'
  

• 排序

  list.sort() 改变本身

  a = ['c', 'b', 'a']
  a.sort()
  a	# ['a', 'b', 'c']
  

  ​

元组类型

tuple 是另一种有序的集合，特点为一旦初始化，元素就不能重新赋值。且它也没有能操作元素的方法。

创建

ages = (16,18,30)

取值

len(ages)	# 3
ages[2]		# 30
ages[0]		# 16

特别注意

ages = ()	# 空元组
ages = (1)	# 并不是元组，而是1
ages = (1,)	# 包含一个元素的元组

字典

dict 类型，全称 dictionary，其他语言里称为 map，使用键值存储，查找速度快。

ages = {
    '李白':17,
    '杜甫':18,
    '白居易':19
}
ages['李白']	# 17

写

ages['李白'] = 50

读

ages['唐太宗']	   # 报错，不存在对应的key

ages.get('唐太宗') 	# None
ages.get('唐太宗',-1) 	# -1

####或者
'唐太宗' in ages	# False

删除元素

ages.pop('李白')

set

set 和 dict类似，也是一组key的集合，但不存储value，可以看成数学意义上的无序和无重复元素的集合。

创建一个set，需要提供一个list作为输入集合

s = set([1,2,2,3,3])
s	# {1,2,3}  重复元素会被过滤

• 添加元素

  s.add()

  s.add(4)	# {1,2,3,4}
  s.add(4)	# {1,2,3,4} 重复添加的元素会被过滤
  

• 删除元素

  s.remove()

  s.remove(4)	# {1,2,3}
  s.remove(4)	# 报错，不存在 4  
  

• 交集 并集

  s1 = set([1,2,3])
  s2 = set([2,3,4])
  s1 & s2		# {2,3} 
  s1 | s2		# {1,2,3,4}
  

  ​

基本语法

---

注意语法的冒号

条件判断

if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

循环

names = ['李白','杜甫','白居易']
for name in names:
    print(name)
    
for i in range(100):     # 从0开始，小于100的整数
    print(i)

n = 99
while n > 0:
    print(n)
    n = n - 2

break 退出循环

continue 跳过该次循环

函数

---

常用函数

• 数学函数

  abs() 绝对值

  abs(-20)	# 20
  abs(1.34)	# 1.34
  

  max() 取最大值

  max(1,1.78,-5,55.55)	# 55.55
  

  hex() 数字转十六进制字符

  hex(255)	# '0xff'
  

  ​

• 数据类型转换

  int('123')	# 123
  int(12.34)	# 12   转整数
  
  float('12.34')	# 12.34
  float('222')	# 222.0	 转浮点数
  
  str(1.23)	# '1.23'  转字符型
  
  bool(1)		# True	 转布尔型
  
  list(range(5))	# 转列表 
  

函数定义

格式

def 函数名(参数):

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

空函数

def fun():
    pass	# 用 pass 占位，防止报错

返回多个值

实际上是返回一个tuple，赋值操作时tuple特性会逐一赋值

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

a,b = add(4,7)
print(a,b)	# 5 8

c = add(4,7)
print(c)	# (5,8)

默认参数（可选参数）

def fun(x = 5) 提前给予默认值

def fun(x = 5):
    return x*x

fun()	# 25
fun(4)	# 16

当可选参数较多时，调用时可选择性输入

def login(name,age = 18,city = "杭州"):
	pass

login('小明',city = "常州")	# 调用时，选择性输入

可变参数（多个参数）

*形参 定义时，形参会是一个tuple来接收所有参数

def sum(*num):
    res = 0
    for i in num:
        res = res + i
    return res

sum()        # 0
sum(3,1,6)	 # 10	

*实参 调用时，允许直接使用 list 和 tuple，相当于直接赋给形参了

sum(*[1,2,3])	# 6
sum(*(2,3,6))	# 11

关键字参数

**形参 定义时，用dict接收所有参数

def func(**some):
    print(some)
    
func()	# {}
func(3)	# 报错，不接受该种形式传参
func(name = '小白',age = 18)	# {'name': '小白', 'age': 18}

####### 修改
def func(lv = 0,**some):
    print(some)
    
func()	# {}
func(3)	# {}
func(name = '小白',age = 18)	# {'name': '小白', 'age': 18}

**实参 调用时，直接使用dict传递，形参获得实参的拷贝

obj = {
    'name':'小白',
    'age':18,
}
func(**obj)	# {'name': '小白', 'age': 18}

命名关键字参数

只接收特定key的参数，用*分隔

def note(name,age,*,city,job):
    print(name,age,city,job)
    
note('小白',18,city="杭州",job='teacher')	# 小白 18 杭州 teacher
note('小白',18)	# 报错，缺少2个 keyword-only arguments

#### 修改
def note(name,age,*,city = "常州",job):
    print(name,age,city,job)
    
note('小白',18,job='teacher')	# 小白 18 杭州 teacher
note('小白',18)	# 报错，缺少1个 keyword-only arguments

参数组合

参数在定义时可以组合使用，但必须保证一定的顺序，该顺序为

必选参数 → 默认参数 → 可变参数 → 命名关键字参数 → 关键字参数

递归函数

def fact(n):
    if n == 1:
        return 1
    return n * fact(n-1)

防止栈溢出

解决递归调用栈溢出的方法是通过尾递归优化

尾递归 在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。

示例函数由于使用了乘法表达式，所以就不是尾递归了。尾递归要求只能返回一个表达式，所以，我们就需要把上一次的执行结果放到参数中传递下去。

def fact(n,result = 1):
    if n == 1:
        return result
    return fact(n-1,n*result)

不过python解释器并未对尾递归做优化，所以栈溢出还是会存在

高级特性

---

切片：

# 获取list或tuple指定索引范围的数据
L = [1,2,3,"haha"]
L[0:3]   # [1,2,3]  序号0开始，不包括序号3
L[:3]    # 同上
L[-2:]   # [3, 'haha']  支持倒数序号
L[-2:-1] # [3]

L[:2:2]  # [1] 前2个，每两个取一个
L[::2]   # [1,3] 所有元素，每两个取一个

复制list

L[:]  # 复制了L

字符切片

'ABCDEFG'[:3]  # 'ABC'
'ABCDEFG'[::2] # 'ACEG'

迭代：

for循环遍历

迭代list或tuple

a = [1,2,3]
for i in a:
    print(i)

迭代dict

# 迭代顺序不一定
d = {'a': 1, 'c': 2, 'b': 3}
for key in d:
    print(key)
# a
# c
# b

# 迭代 value
d = {'a': 1, 'c': 2, 'b': 3}
for value in d.values():
    print(value)

# 迭代 key & value
d = {'a': 1, 'c': 2, 'b': 3}
for k, v in d.items():
    print(k,v)
# a 1
# c 2
# b 3

迭代字符串

for ch in 'ABC':
    print(ch)
# A
# B
# C

判断是否可迭代 通过collections模块的Iterable类型判断

from collections import Iterable
isinstance('abc', Iterable) # True  str是否可迭代
isinstance([1,2,3], Iterable) # True  list是否可迭代
isinstance(123, Iterable) # False  整数是否可迭代

迭代下标 -- Python内置的enumerate函数

# enumerate
for i, value in enumerate(['A', 'B', 'C']):
    print(i, value)
# 0 A
# 1 B
# 2 C

迭代内容

for x, y in [(1, 1), [2, 4], (3, 9)]:
    print(x, y)
# 1 1
# 2 4
# 3 9
## 子 tuple 或 子 list 长度只能为 2

列表生成式：

list()

list(range(1, 11))  # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

生成更复杂的列表

### 常规做法
L = []
for x in range(1, 11):
    L.append(x * x)
print(L)  
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

### 类似map的做法
[x * x for x in range(1, 11)]  
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
[x * x for x in range(1, 11) if x % 2 == 0] 
# [4, 16, 36, 64, 100]  加判断
[m + n for m in 'ABC' for n in 'XYZ']  
# ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ'] 双重循环

小结: 复杂的列表生成式包含js中map和filter方法，并且扩展性更大，可以循环dict,还可以可以双重循环，总的来说自由度更高，使用需要上点心。

生成器：

不必创建完整的list，边循环边推演获得后续元素，从而可以节约空间。这种机制被称为生成器：generator

L = [x * x for x in range(10)] # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

g = (x * x for x in range(10)) # <generator object <genexpr> at 0x000000CC0A38A518>

和列表生成器的区别就在于外层是()

获取generator的下一个元素

next(g) # 0
next(g) # 1
next(g) # 4
next(g) # 9
...

循环generator

g = (x * x for x in range(10))
for n in g:
    print(n)
# 0
# 1
# 4
# ...
# 81

generator函数

#### 普通斐波那契数列
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        print(b)
        a, b = b, a + b
        n = n + 1
    return 'done'

fib(5)  # 1
        # 1
        # 2
        # 3
        # 5
        # 'done'
        
#### generator函数  yield关键字
def fib(max):
    n, a, b = 0, 0, 1
    while n < max:
        yield b
        a, b = b, a + b
        n = n + 1
    return 'done'  # 执行到这句会终止函数 但是返回值无法直接获取
    
fib(5) # <generator object fib at 0x0000003C89A1A570>

for n in fib(5):
    print(n)
# 1
# 1
# 2
# 3
# 5

generator函数的执行顺序

### 遇到 yield就中断，但依靠循环可以不断执行下去

def odd():
    print('step 1')
    yield 1
    print('step 2')
    yield(3)
    print('step 3')
    yield(5)

a = odd()  # a赋值成一个generator对象
next(a) # 打印'step1'  返回值为1
next(a) # 打印'step2'  返回值为3
next(a) # 打印'step3'  返回值为5

小结: 生成器有两种形式，简单逻辑通过()包装即可，复杂逻辑则需要通过函数形式并配合yield关键字实现。两种方式都是为了保存某种算法，通过算法可以计算推导出每一项。

迭代器：

可直接作用于for循环的对象统称为可迭代对象：Iterable

判断对象是否可迭代

from collections import Iterable

isinstance([], Iterable)    # True
isinstance({}, Iterable)    # True
isinstance('abc', Iterable) # True
isinstance((x for x in range(10)), Iterable)    # True
isinstance(100, Iterable)   # False

可以被next()方法调用并不断返回下一个值的对象称为迭代器：Iterator

判断对象是否是迭代器对象

from collections import Iterator

isinstance([], Iterator)    # False
isinstance({}, Iterator)    # False
isinstance('abc', Iterator) # False
isinstance((x for x in range(10)), Iterator)    # True
isinstance(100, Iterator)   # False


### iter()方法可将 list、dict、str等变成迭代器对象
isinstance(iter([]), Iterator)    # True
isinstance(iter('abc'), Iterator) # True

函数式编程

---

高阶函数

• map/reduce

map 接收两个参数，一个是函数，一个是Iterable，新结果作为Iterator返回

def f(x):
    return x * x
r = map(f,[1,2,3])  # <map object at 0x000000D84BDFFF28>
list(r)     # [1,4,9]  计算 Iterator,获得完整的 list

reduce 接收两个参数，一个是函数，一个是Iterable，高阶函数的参数为计算结果和下一个元素

from functools import reduce

def add(x, y):
    return x + y
r = reduce(add, [1, 2, 3])  # 6

### lambda函数
r = reduce(lambda x, y : x + y,[1,2,3])  # 6

• filter

filter 接收一个函数，一个Iterable，返回Iterator

def is_odd(n):
    return n % 2 == 1
    
r = filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])
list(r) # [1, 5, 9, 15]

####返回所有素数
## 算法 埃氏筛法

def origin():  # 初始序列
    n = 2
    while True:
        yield n
        n = n + 1
        
def not_divisible(n): 
    return lambda x: x % n != 0   # 表示不能整除

def primes():   # 素数序列
    arr = origin()
    while True:
        n = next(arr) # 返回序列的第一个数
        yield n 
        arr = filter(not_divisible(n),arr) # 筛除部分非素数

• sorted

sorted 接收一个Iterable，接收一个key函数，返回一个list

a = [36, 5, -12, 9, -21]
sorted(a)  # [-21, -12, 5, 9, 36]
print(a)   # [36, 5, -12, 9, -21]  不会改变原列表

####添加 key函数
sorted(a, key=abs)   # [5, 9, -12, -21, 36]
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) 
# ['about', 'bob', 'Credit', 'Zoo']
sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) 
# ['Zoo', 'Credit', 'bob', 'about']   反向

####自定义 key函数
def by_name(t):
    return t[0].lower()
sorted([('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)],key=by_name)
# [('Adam', 92), ('Bart', 66), ('Bob', 75), ('Lisa', 88)]

### 特别注意
sorted("bacdge")  # ['a', 'b', 'c', 'd', 'e', 'g']

返回函数（闭包）

即函数作为返回值，也可以称为函数生成器

### python的作用域貌似有点严格
def createCounter():
    n = 0
    def counter():
        nonlocal n  # nonlocal 关键字   用来声明变量需要向上一层寻找
        n = n + 1
        return n

    return counter

counterA = createCounter()
print(counterA(), counterA(), counterA(), counterA(), counterA()) # 1 2 3 4 5

### 引用类型不需要 nonlocal关键字
def createCounter():
    arr = [0]
    def counter():
        arr[0] = arr[0] + 1
        return arr[0]

    return counter

匿名函数（lambda）

没有 return，不能遍历，不能使用 if: else:分支

add = lambda x,y: x + y   # 带参数

add = lambda x,y: x + y if y >= 0 else x  # 三元判断符

def add(x, y):
    return lambda: x + y  # 无参数

装饰器

增强某函数的功能，但又不希望修改原函数的定义，这种在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

### 定义一个函数做装饰器 接收一个函数 并返回一个函数
def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)  # 打印函数名称
        return func(*args, **kw)
    return wrapper
    
# '@'关键字  在函数定义处设置装饰器
@log     
def now():
    print('today')

now()  
# call now():
# today

@log放在函数定义处等价于 now = log(now)

装饰器可传入参数 （等于多包了一层函数）

#### 装饰器传入参数
def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s():' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
        
    return decorator

@log('execute')
def now():
    print('today')
    
now()
# execute now()
# today

### 等价于  now = log('execute')(now)

最后的问题 now.__name__为wrapper

#### 解决最终问题
### functools.wraps

import functools

def log(func):
    @functools.wraps(func)  ### 关键句  用装饰器包装 wrapper 函数
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__)
        return func(*args, **kw)
    return wrapper

偏函数（Partial function）

提前给定参数的函数生成器

int('10')  # 10
int('10',base=2) # 2

### 偏函数  2进制转10进制
import functools
int2 = functools.partial(int,base=2) # 原函数 和 给定参数
int2('10') # 2

小结
偏函数可以固定参数，用来简化函数调用，在原函数分支较多，或者参数过多的情况下，可以用偏函数优化。