Python学习记录

基础语法

基础语法

输出：print()

输入：a = input() 给a赋值 （）内可以输入提示信息 比如 “请输入你的姓名”

数据类型：

• 整数：可以处理任意大小的整数
• 浮点数：
• 字符串：用单引号或双引号括起来的任意文本
• 布尔值：true false and or not 与或非运算 常用于条件判断
• None：空值 不能理解为0 是一个特殊的空值
• 变量：可以是任意数据类型

字符编码：

list：python内置的数据类型；有序集合，数据类型可以不同、可以包含list、可以随时添加和删除其中的数据。

• len()：获得元素的个数
• 用索引来访问其中的元素，从0开始 直接获取最后一个元素可以用-1、
• append()：追加元素到末尾
• insert：把元素插入到指定位置
• pop：删除末尾元素
• pop（i）：删除指定
• array[i] = ‘’:直接替换索引为i的元素

classmates = ['aa','bb','cc']
print(classmates)
print(len(classmates))
print(classmates[0])
classmates.append('dd')
print(classmates)
classmates.insert(1,'11')
print(classmates)
print(classmates.pop())
print(classmates)
print(classmates.pop(1))
print(classmates)
classmates[1] = 'hh'
print(classmates)

# 结果
['aa', 'bb', 'cc']
3
aa
['aa', 'bb', 'cc', 'dd']
['aa', '11', 'bb', 'cc', 'dd']
dd
['aa', '11', 'bb', 'cc']
11
['aa', 'bb', 'cc']
['aa', 'hh', 'cc']

tuple

元组：有序列表、一旦初始化不能修改，如果元组中包含list，则list的数据是可以修改的

使用元组的意义：比list更加安全

条件判断

a = 10
if a == 9:
	print('aa')
elif a == 10:
	print('bb')
else:
	print('cc')

int()函数可以将str转换成int

range()：生成一个整数序列

循环

names = ['aa','bb','cc']
for name in names:
  print(name)

sum = 0
for x in [1,2,3,4,5,6,7,8,9,10]:
  sum = sum + x
print(sum)

break提前退出循环

dist

字典：使用键值存储，查找速度极快

d = {'aa':11,'bb':22,'cc':33}
print(d['aa'])
d.get('aa')
d.pop('aa')

set

是一组key的集合，不存储value、key不能重复、创建一个set、需要提供一个list作为输入集合
重复元素在set中自动被过滤、add（）添加元素到set中，

函数

函数

定义函数

def myfuncation(x):
	...函数体
# 空函数
def nop():
    pass  #pass语句什么都不做，当作占位符，让程序能够运行起来
# 类型检测 在函数体执行前对传入的参数进行检查  
if not isinstance(x, (int, float)):
    raise TypeError('bad operand type')
# 可以返回多个值

# 在定义函数时，需要确定函数名和参数个数
# 如果有必要，可以先对参数的数据类型做检查
# 函数内部可以用retur随时返回函数结果
# 函数执行完毕也没有return语句  自动return none
# 函数可以同时返回多个值 

高级特性

高级特性

切片

slice：取几个元素

names = ['aa','bb','cc','dd','ff']
names[0:3]

#前10个数，每两个取一个
L[:10:2]
#所有数，每5个取一个
L[::5]
#元组的切片还是元组
#字符串也可以切片
'ABCDEFG'[:3]
'ABC'

迭代

提供for循环遍历列表或元组 for in
默认情况下字典迭代的是key，如果要迭代value的话，for k,v in d.items()
字符串也可以迭代
判断对象是不是可迭代对象：

from collections.abc import Iterable
isinstance('abc',Iterable)  # str是否可迭代

python内置的enumerate函数可以把list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身

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

列表生成式

用来创建list的生成式
比如：要生成list[1,2,3,4,5,6,7,8,9,10]可以用list(range(1,11)):

L = []
for x in range(1,11):
	L.append(x*x)
# 结果
[1,4,9,16,....]

# 使用列表生成式
[x * x for x in range(1, 11)]
# 还可以加if判断
[x * x for x in range(1, 11) if x % 2 == 0]
# 还可以使用两层循环
[m + n for m in 'ABC' for n in 'XYZ']

生成器

列表容量有限，生成器可以一边循环一边计算，创建生成器有很多种方法，第一种方法：把列表生成式的[]改成（），

//list
L = [x * x for x in range(10)]
L   [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
//generator
g = (x * x for x in range(10))
g	<generator object <genexpr> at 0x1022ef630>

//打印generator
next(g)		0
next(g)		1

//一般使用迭代的方式输出generator
g = (x * x for x in range(10))
for n in g:
    print(n)
    
# 结果
0
1
4
9
...
81

调用generator函数会创建一个generator对象，多次调用generator函数会创建多个相互独立的generator

迭代器

可以直接作用于for循环的数据类型：

• 集合：list、tuple、dict、set、str等
• generator：生成器

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

可以作用于next()函数的对象都是Iterator类型

可以使用isinstance()判断一个对象是否是Iterable对象

python的for循环本质上就是通过不断调用next()函数实现的

函数式编程

函数式编程

map

接收两个参数，一个是函数、一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回

example：
有一个函数，f(x) = x*x，要把这个函数作用在一个list上，就可以用map()实现如下

def f(x):
   return x * x
...
r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
list(r)
// 结果
[1, 4, 9, 16, 25, 36, 49, 64, 81]

reduce

把一个函数作用在一个序列上，这个函数必须接收两个参数，reduce把结果和序列的下一个元素做累积计算。

example：
对一个序列求和

from functools import reduce
def add(x, y):
	return x + y
reduce(add, [1, 3, 5, 7, 9])
# 结果
25

filter

过滤器：用于过滤序列，和map不同的是，filter是把传入的函数依次作用于每个元素，然后根据返回值是true函数false决定保留还是丢弃该元素

example：

# 在一个list中，删除偶数，只保留奇数：
def is_odd(n):
    return n % 2 == 1

list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
# 结果: [1, 5, 9, 15]

# 把一个序列中的空字符串删掉，可以这么写：
def not_empty(s):
    return s and s.strip()

list(filter(not_empty, ['A', '', 'B', None, 'C', '  ']))
# 结果: ['A', 'B', 'C']

filter函数返回的是一个Iterator，也就是一个惰性序列。所以要强迫filter完成计算结果，需要用list函数获得所有结果并返回list

sorted

排序
排序的核心是什么？？ 比较两个元素的大小

sorted([36, 5, -12, 9, -21])
# 结果
[-21, -12, 5, 9, 36]

可以接收一个key函数来实现自定义的排序，比如按照绝对值大小排序：

sorted([36, 5, -12, 9, -21], key=abs)
# 结果
[5, 9, -12, -21, 36]

key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序

函数返回值

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

匿名函数

不需要显示地定义函数，直接传入匿名函数更加方便
lambda x：x * x
且匿名函数只能有一个表达式，不用写return，返回值就是该表达式的结果

装饰器