Python快速入门

代码风格建议

• 建议遵循以下约定
  • 使用4个空格来缩进
  • 永远不要混用空格和制表符
  • 在函数之间空一行
  • 在类之间空两行
  • 字典、列表、元组以及参数列表中，在",“后添加一个空格。对于字典，”:"后面页添加一个空格
  • 在赋值运算符和比较运算符周围要有空格(参数列表中除外)，但是括号里侧不加空格
    • a = f(1, 2) + g(3, 4)

变量和数据类型

单行定义多个变量或赋值

• 你可以在一行内将多个值赋值给多个变量

# 赋值
>>> a, b = 45, 54
>>> a
45
>>> b
54
# 交换数值
>>> a, b = b, a
>>> a
54
>>> b
45

• 要明白这时怎么工作的，你需要学习元组(tuple)这个数据类型。我们是用逗号创建元组。在赋值语句的右边我们创建了一个元组，我们称这位元组封装(tuple packing)，赋值语句的左边我们则是做元组拆封(tuple unpacking)

>>> data = ("one", "two", "three")
>>> name, age, sex = data
>>> name
one
>>> age
two
>>> sex
three

运算符和表达式

整数运算符

• 只有有任意一个操作数是浮点数，结果就会是浮点数
• 进行除法运算时若是除不尽，结果将会是小数，这很自然，如果要进行整除，使用"//"运算符，他将会返回商的整数部分
• "%"是取余运算符

关系运算符

Operator	Meaning
<	is less than
<=	is less than or equal to
>	is greater than
>=	is greater than or equal to
==	is equal
!=	is not equal to

逻辑运算符

• 对于逻辑 与、或、非，我们使用and、or、not这几个关键字
• 逻辑运算符 and 和 or 也称作短路运算符：他们的参数从左向右解析，一旦结果可以确定就停止。
  • 例如：如果A和C为真，而B为假，A and B and C 不会解析C。
  • 作用于一个普通的非逻辑值时，短路运算符的返回值通常是能够最先确定结果的那个操作数
• 关系运算可以通过逻辑运算符 and 和 or 组合，比较的结果可以用not来取反义
• 逻辑运算符的优先级又低于关系运算符，在他们之中，not > and > or

简写运算符

• x op= expression 为简写运算的语法形式，其等价于 x = x op expression

>>> a = 12
>>> a += 13
>>> a
25
>>> a /= 3
>>> a
8
>>> a += (26 * 32)
>>> a
840.333333333334

类型转换

类型转换函数	转换路径
float(string)	字符串 -> 浮点值
int(string)	字符串 -> 整数值
str(interger)	整数值 -> 字符串
str(float)	浮点值 -> 字符串

控制流 IF-ELSE

选择

# if - else
if expression:
    do this
else:
    do other
# if - else - if
if expression1:
    do this
elif expression2:
    do this
else:
    do other

# 检测真值的优雅方式：
if x:
    pass
# 而不是下面这样：
if x == True:
    pass

循环

while循环

while condition:
    statement1
    statement2

• 默认情况下，print()除了打印你提供的字符串之外，还会打印一个换行符，所以每次调用一次print()就会换一次行
• 你可以通过print()的另一个参数来替换这个换行符
  • print(string, end = ’ ')
• print("-" * 50)：字符串若是乘上整数n，将返回由n个此字符串拼接起来的新字符串

列表

# 列表索引从 0 开始
>>> a = [1, 2, 3, 'In', 'Out']
>>> a
[1, 2, 3, 'In', 'Out']
# 可以通过索引来访问列表中的值
>>> a[0]
1
# 如果索引为负数，那将会从列表的末尾开始计数
>>> a[-1]
'Out'
# 你还可以将它切成不同的部分，这个操作成为切片(左闭右开)
>>> a[0:-1]
[1, 2, 3, 'In']
>>> a[2:-2]
[3]
# 切片不会改变正在操作的列表，切片操作返回其子列表，这意味着下面的操作返回列表的一个新的拷贝副本
>>> a[:]
[1, 2, 3, 'In', 'Out']
# 切片的索引由非常有用的默认值；省略第一个索引默认为0；省略第二个索引默认为列表的长度
>>> a[:-2]
[1, 2, 3]
>>> a[-2:]
['In', 'Out']

• 有个办法可以很容易地记住切片的工作方式：切片时的索引时在两个元素之间。左边第一个元素的索引为0，而长度为n的列表其最后一个元素的右界索引为n

 +-----+-----+-----+------+-------+
 |  1  |  2  |  3  |  In  |  Out  |
 +-----+-----+-----+------+-------+
 0     1     2     3      4       5
-6    -5    -4    -3     -2      -1

• 上面的第一行数字给出列表中索引点0…6，第二行给出相应的负索引
  • 对于非负索引，如果上下都在边界内，切片长度就是两个索引之差

# Python能够优雅地处理那些没有意义的切片索引：一个过大的索引值将被列表的实际长度所代替，当上边界比下边界大时(即切片左值大于右值)就返回空列表
>>> a[2:42]
[3, 'In', 'Out']
>>> a[32:]
[]
# 切片操作还可以设置步长(即从切片索引i到索引j，每个n个元素取值)
>>> a[1::2]
[2, 'In']
# 列表也支持连接操作，返回一个新的列表
>>> a + [5, 6, 7]
[1, 2, 3, 'In', 'Out', 5, 6, 7]
# 允许修改元素
>>> a[2] = 'fuck'
>>> a
[1, 2, 'fuck', 'In', 'Out']
# 也可以对切片赋值，此操作可以改变列表的长度
>>> a
[1, 2, 'fuck', 'In', 'Out']
# 替换某些值
>>> a[1:3] = ['you', 'me']
>>> a
[1, 'you', 'me', 'In', 'Out']
# 移除某些值
>>> a[1:3] = []
>>> a
[1, 'In', 'Out']
# 清空列表
>>> a[:] = []
>>> a
[]

• 要检查某个值是否存在于列表中：‘me’ in a(返回false)
• 获得列表的长度：len(a)

# 检查列表是否为空
if list_name:# 列表不为空
    pass
else:#列表为空
    pass

# 列表是允许嵌套的
>>> a = ['a', 'b', 'c']
>>> b = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

for循环

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

• range()函数
  • 如果你需要一个数值序列，内置函数range()会很方便的生成一个等差数列(并不是列表)

continue语句

• 如同break，我们可以在循环中使用continue，他会跳过其后的代码回到循环开始处执行
• 这意味着它可以帮助你跳过部分循环

循环后的else语句

• 我们可以在循环后面使用可选的else语句，他将会在循环完毕后执行，除非有break语句终止了循环

for i in range(0, 5):
    print(i)
else:
    print("Good Bye!")

数据结构

列表

# 创建一个列表a
>>> a = [23, 45, 1, -3434, 43624356, 234]

# 1、a.append(var)，将var元素插入到列表末尾
>>> a.append(45)
>>> a
[23, 45, 1, -3434, 43624356, 234, 45]

# 2、a.insert(index, var)，将var元素插入到指定索引位置
>>> a.insert(0, 111)
>>> a
[111, 23, 45, 1, -3434, 43624356, 234]

# 3、a.count(var)，返回列表中var元素出现的个数
>>> a.count(45)
2

# 4、a.remove(var)，将var元素从列表中移除
>>> a.remove(111)
[23, 45, 1, -3434, 43624356, 234, 45]

# 5、a.extend(b)，将列表b中的元素添加到a列表中
>>> b = [11, 22]
>>> a.extend(b)
>>> a
[23, 45, 1, -3434, 43624356, 234, 45, 11, 22]

# 6、a.sort()，对列表进行排序(前提是列表是可比较的)
>>> a.sort()
>>> a
[-3434, 1, 11, 22, 23, 45, 45, 234, 43624356]

# 7、使用del关键字删除指定位置的列表元素
>>> del a[-1]
>>> a
[-3434, 1, 11, 22, 23, 45, 45, 234]

# 8、a.pop(i)，i不存在时，默认弹出最后面元素，否则弹出指定位置的元素
>>> a.pop()
>>> a
[-3434, 1, 11, 22, 23, 45, 45]
>>> a.pop(0)
>>> a
[1, 11, 22, 23, 45, 45]

列表推导式

• 列表推导式为从序列中创建列表提供了一个简单的方法。如果没有列表推导式，一般都是这样创建列表的：通过将一些操作应用于序列的每个成员并通过返回的元素创建列表，或者通过满足特定的元素创建子序列

# 假设我们创建一个squares列表，可以像下面这样创建
>>> squares = []
>>> for x in range(10):
...     squares.append(x ** 2)
...
>>> squares
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 注意这个for循环中的被创建(或被重写)的变量x在循环完毕后依然存在

# 我们可以计算squares的值而不会产生任何的副作用
squares = list(map(lambda x: x**2, range(10)))

# 等价于下面的列表推导式
squares = [x**2 for x in range(10)]

• 列表推导式由包含一个表达式的中括号组成，表达式后面跟随一个for语句，之后可以有零个或多个for或if语句。结果是一个列表，由表达式依据其后面的for和if子句上下稳计算而来的结果构成

>>> [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
[(1,3),(1,4),(2,3),(2,1),(2,4),(3,1),(3,4)]

# 等同于
>>> combs = []
>>> for x in [1, 2, 3]:
...     for y in [3, 1, 4]:
...          if x != y:
...              combs.append((x,y))
>>> combs
[(1,3),(1,4),(2,3),(2,1),(2,4),(3,1),(3,4)]

# 列表推导式也可以嵌套
>>> a = [1, 2, 3]
>>> z = [x+1 for x in [x**2 for x in a]]
>>> z
[2, 5, 10]

元组

# 元组是由数个逗号分隔的值组成
>>> a = 'a','b','c'
>>> a
('a','b','c')
>>> a[1]
'b'

# 可以对任何一个元组执行拆封操作并赋值给多个变量
# divmod()函数返回包含商和余数的元组
>>> divmod(15, 2)
(7,1)

# 元组是不可变类型，这意味着你不能在元组内删除或添加或编辑任何值
# 要创建只含有一个元素的元组，在值后面跟一个逗号
# 通过内建函数type()可以知道任意变量的数据类型
>>> a = (123)
>>> a
123
>>> type(a)
<class 'int'>
>>> b = (123, )
>>> b
(123,)
>>> type(b)
<class 'tuple'>

集合

• 集合是一个无序不重复元素的值。基本功能包括关系测试和消除重复元素
• 集合对象还支持union(联合)、intersection(交)、difference(差)和symmetric difference(对称差集)
• 大括号或set()函数可以用来创建集合
  • 注意：想要创建空集合，你必须使用set()而不是{}。(后者用于创建空字典)

关系测试

>>> basket = {'a', 'b', 'c', 'd', 'c'}
# 可以看到输出的顺序不一样，重复元素也被去除
>>> print(basket)
{'b', 'c', 'a', 'd'}

>>> 'b' in basket
True
>>> 'e' in basket
False

# 两个单词中的字母进行集合操作
>>> a = set('abracadabra')
>>> b = set('alacazam')
# a去重后的字母
>>> a
{'a', 'r', 'b', 'c', 'd'}

# a有而b没有的字母：差集：a.different(b)
>>> a - b
{'r', 'd', 'b'}

# 存在于a或b的字母：并集：a.union(b)
>>> a | b
{'a', 'c', 'r', 'd', 'b', 'l', 'm', 'z'}

# a和b都有的字母：交集：a.intersection(b)
>>> a & b
{'a', 'c'}

# 存在于a或b，但不同是存在的字母：对称差集：a.symmetric_different(b)
>>> a ^ b
{'r', 'd', 'b', 'm', 'z', 'l'}

# 子集 or 父集
>>> a.issubset(b)	# 子集判断
False
>>> a.issuperset(b)	# 父集判断
False

# 判断是否有交集：无交集返回True；反之返回False
>>> a.isdisjoint(b)
True

基本操作

>>> a = set([11, 22, 33])
>>> a
{22, 11, 33}
# add操作：单独添加一个集合元素的操作
>>> a.add(44)
>>> a
{11, 33, 44, 22}
# update操作：添加多个集合元素
>>> a.update([55,66])
>>> a
{33, 66, 11, 44, 22, 55}
# remove操作：删除其中的一项：在删除不存在的元素时会报错
>>> a.remove(66)
>>> a
{33, 11, 44, 22, 55}
# len操作：确定元素个数
>>> len(a)
5
# in操作：成员判断操作
>>> 11 in a
True
>>> 11 not in a
False
# pop操作：删除任意的一个，并返回删除的元素
>>> a.pop()
33
>>> a
{11, 44, 22, 55}
# discard操作：和remove不同的一点在于：discard在指定删除不存在的元素时不会报错
>>> a.discard(33)
>>> a
{11, 44, 22, 55}
>>> a.discard(11)
{22, 55, 44}

字典

• 字典是无序的键值对集合，同一个字典内的键必须是互不相同的。一对大括号{}创建一个空字典
• 初始化字典时，在大括号内放置一组逗号分隔的键:值对，这也是字典的输出方式
• 我们可以使用键来检索存储在字典中的数据

>>> data = {'a':'aaa', 'b':'bbb', 'c':'ccc'}
>>> data
{'a':'aaa', 'b':'bbb', 'c':'ccc'}
>>> data['a']
'aaa'

# 创建新的键值对
>>> data['d'] = 'ddd'
>>> data
{'a':'aaa', 'b':'bbb', 'c':'ccc', 'd':'ddd'}

# 使用 del 关键字删除任意指定的键值对
>>> del data['a']
>>> data
{'b':'bbb', 'c':'ccc', 'd':'ddd'}

# 使用 in 关键字查询指定的键是否存在于字典中
>>> 'b' in data
True

# 必须知道的是：字典中的键必须是不可变类型，比如你不能使用列表作为键
# dict()可以从包含键值对的元组中创建字典
>>> dict((('a', 'b'), ('c', 'd')))
{'a':'b', 'c':'d'}

# 使用items()方法可以遍历字典
>>> data
{'b':'bbb', 'c':'ccc', 'd':'ddd'}
>>> for x, y in data.items():
...     print("{} uses {}".format(x, y))
b uses bbb
c uses ccc
d uses ddd

# 很多时候我们需要王字典中的元素添加数据，我们首先要判断这个元素是否存在，不存在则创建一个默认值
# 如果在循环里执行这个操作，每次迭代都需要判断一次，降低程序性能
# 我们可以使用dict.setdefault(key, default)有效率的完成这个事情
>>> data = {}
>>> data.setdefault('names',[]).append('Ruby')
>>> data
{'names':['Ruby']}
>>> data.setdefault('names',[]).append('Python')
>>> data
{'names':['Ruby', 'Python']}
>>> data.setdefault('names',[]).append('Java')
>>> data
{'names':['Ruby', 'Python', 'Java']}

# 试图索引一个不存在的键时将会抛出一个KeyError的错误
# 我们可以使用dict.get(ley, default)来索引键。如果键不存在，那么返回指定的default值
>>> data['floo']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'floo'

>>> data.get('floo', 0)
0

# 如果你像遍历列表(或任何序列类型)的同时获得元素索引值，你可以使用 enumrate()
>>> for i, j in enumrate(['a', 'b', 'c']):
... print(i, j)
...
0 a
1 b
2 c

# 当你需要同时遍历多个序列类型，你可以使用 zip() 函数
>>> a = ['a', 'b']
>>> b = ['c', 'd']
>>> for x, y in zip(a, b):
...     print("{} uses {}".format(x, y))
...
a uses c
b uses d

文件操作

基本操作

count = 0
# 读取操作："r"
f = open("yesterday", "r", encoding='UTF-8')
for line in f:
# 去掉空格和换行
    print(line.strip())
    count += 1

# 写入操作："w"文件存在则覆盖；文件不存在则创建新文件
f = open("yesterday", "w", encoding='UTF-8')
f.write("hehehe")
f.close()

# 追加操作："a"不能执行读操作
f = open("yesterday", "a", encoding='utf-8')
f.write("\n呵呵呵")
f.close()

其他方法

f = open("yesterday","r",encoding='utf-8')
# 读取文件行位置(按字符个数计数)
f.tell()
# 按行读取
f.readline()
# 按字符读取
f.read(n)
# 返回文件编码
f.encoding
# 返回文件在内存中的编号
f.fileno()
# 返回文件名称
f.name
# 判断文件是否可读
f.readable()
# 判断文件是否可写
f.wirtable()
# 将内容刷到硬盘
f.flush()
# 截断
f.truncate(n)
# 替换操作
if "xxx" in line: line = line.replace("xxx", "yyy")

函数式编程

函数的定义

def test(x):
    "the function of description"
    x += 1
    return x
"""
def：定义函数的关键字
test：函数名
(x)：x为形式参数
""：定义函数的描述
x+=1：处理逻辑
return：定义返回值
"""

函数和过程

# 函数
def fun1():
    print("in the fun1")
    return 0

# 过程：没有return这个函数
def fun2():
    print("in the fun2")
    
x = fun1()
y = fun2()

函数的优点

• 实现代码的扩展性；简化代码；保持数据的一致性

import time

def logger():
    time_format = '%Y-%M-%d %X'
    time_current = time.strftime(time_format)
    # 文件追加
    whih open('a.txt','a') as f:
        f.write('%s wndaction\n' %time_current)

# 测试函数
def test1():
    print("test1 starting action")
    logger()
def test2():
    print("test2 starting action")
    logger()
def test3():
    print("test3 starting action")
    logger()

函数的返回值

• 代码执行结果的返回值可以通过返回值体现出代码执行的状态结果是怎样的

def test1():
    print("in the test1")
    #结束程序，并返回值,不再执行此函数体内的下面部分代码
    return 0
    print('test end')
    
def test2():
    print("in the test2")
    
def test3():
    print("in the test3")
    #返回值的类型比较多，最终将返回到一个元组中
    return 1,'hello',['hehe','gaga'],{'name':'king'}

位置参数和关键字调用

def test(x, y):
    print(x)
    print(y)
# 这里的1,2是x,y的位置参数，也叫实参，是内存中实际存在的值。而x,y为形参，不会占内存空间
test(1, 2)
# 所有的形参和实参是一一对应的不能多也不能少
# 这是关键字调用的表示方法，要记住关键字调用和位置参数的位置：位置参数要位于关键字调用之前
test(x=3,y=4)

默认参数

def test(x, y=2):
    print(x)
    print(y)
# 调用函数的时候，默认参数是非必传参数，用于默认安装路径等。如果传递了相当于是修改默认参数
test(1, 3)
# 默认安装值，以及连接数据库的端口号等

参数组

# 第一种参数组：接受N个位置参数转换成元组的方式
def test1(*args):
    print(args)
# 解决实参不固定的情况下就需要使用参数组来解决这个问题，输出为元组
test1(2,3,4,5)

# 第二种参数组：
def test2(x, *args):
    print(x)
    print(args)
# 可以传递任意的参数值，不限个数
test(1,2,3,4,5,6,7,8,9)

# 第三种参数组：前两种都是能转成不同形式(半元组和全元组)，将N个关键字参数转换成键值对形式存放
# 可以接受字典的参数组
def test3(**kwargs):
    print(kwargs)
# 将N个关键字参数转换成及价值对形式存放
test3(name='a',age=3,sex='male')

# 结合位置参数使用
def test4(name, age=23, **kwargs):
    print(name)
    print(kwargs)
# test4('king', 13, 'male') 这样是错误的
test4('king', gender='male')

# 结合第一种参数组实验
def test5(name, age=22, *args, **kwargs):
    print(name)
    print(aegs)
    print(kwargs)
# 结果会返回一个空的元组，因为后面的关键字参数被转成了字典，由于不存在位置参数，所以元组为空
test5('king', age=25, hobby='IT', birthday=1996)

全局变量和局部变量

• 局部变量：在子程序中起作用
• 全局变量：在当前程序中起作用
• 注意：局部变量里面对于字符串和数字的修改不影响全局变量，然而要是序列类型的话，只要修改了局部变量里面对应的元素就会影响全局变量

高阶函数

• 变量可以指向函数，函数的参数能够接收变量，那么一个函数就可以接收另一个函数作为参数

def add(a, d, f):
    return f(a)+f(b)
res = add(3, -6, abs)

装饰器

• 装饰器的本质是函数，其目的是用来为其他函数增加附加功能
• 原则：不能修改被装饰函数的源代码；被装饰函数的调用方式不能改变，简而言之就是装饰器对于函数就是透明的，对被装饰的函数是没有影响的
• 实现装饰器的知识储备：函数即变量；高阶函数；嵌套函数
• 最终高阶函数加上嵌套函数就构成了装饰器，函数也就是一种变量

高阶函数

# 1、把一个函数名仿作实参传给另外一个函数（不修改装饰函数源代码的情况下为其添加功能）
import time
def test1(func):
    start_time = time.time()
    func()
    end_time = time.time()
    print("total %s" %(end_time - start_time))
def bar():
    time.sleep(3)
    print("in the bar")
    
# 调用
test1(bar)

# 2、返回值中包含函数名(不用修改函数的调用方式)
import time
def test1(func):
    print(func)
    return func
def bar():
    time.sleep(3)
    print("in the bar")
# 调用
bar = test1(bar)
bar()

嵌套函数

def foo():
    print("hello world")
    def bar():
        print("in the bar")
    bar()
# 调用
foo()

装饰器的实现

import time
def timer(func):
    def deco():
        start_time = time.time()
        func()
        end_time = time.time()
        print("total is %s:"%(end_time - start_time))
    return deco

# 调用装饰器
# 其中test1和test2函数相当于是源代码，不改变源代码而实现功能的添加，这就是装饰器的效果
@timer
def test1():
    time.sleep(1)
    print("test1")
@timer
def test2():
    time.sleep(1)
    print("test2")
# 调用
test1()
test2()