python自学笔记第二弹——了解python
目录
- 1. Python简介
-
- 1.1 Python命令行模式和交互模式
- 1.2 Python解释器和文本编辑器
- 2.Python基础
-
- 2.1 数据类型：整数(d)、浮点数(f)、字符串(s)、布尔值、空值（None）、常量
- 2.2 字符串与编码
- 2.3 list 和tuple
- 2.4 条件判断: if, elif, else
- 2.5 循环
- 2.6 dic字典和set集合
- 3.函数
-
- 3.1 定义函数
- 3.2 函数的参数
- 4. 高级特性
-
- 4.1 迭代
- 4.2 列表生成式
- 4.3 生成器（generator）
1. Python简介
1.1 Python命令行模式和交互模式
- 命令行模式，它的提示符：
C:\>。执行一个.py文件只能在命令行模式下。 - 在命令行模式下敲命令python，就看到类似如下的一堆文本输出，然后就进入到Python交互模式，提示符是:
>>>。它是输入一行，执行一行，主要是为了调试Python代码用的，也便于初学者学习，它不是正式运行Python代码的环境！
1.2 Python解释器和文本编辑器
- 重点： Mac 如何在终端执行保存的“.py”文件
- 变量（不同于Java, Python是动态语言）、输入
input()、输出 - input()返回的数据类型是str，str不能直接和整数比较，必须先把str转换成整数。
s = input('birth: ')
birth = int(s)
if birth < 2000:
print('00前')
else:
print('00后')
2.Python基础
2.1 数据类型：整数(d)、浮点数(f)、字符串(s)、布尔值、空值（None）、常量
需要注意的是：
- 对变量赋值x = y是把变量x指向真正的对象，该对象是变量y所指向的。随后对变量y的赋值不影响变量x的指向。
- 整数和浮点数在计算机内部存储的方式不同。整数运算永远是精确的（除法也是精确的），而浮点数运算则可能会有四舍五入的误差
- 转义字符：\n表示换行，\t表示制表符，字符\本身也要转义，所以\表示的字符就是\。为了简化，Python还允许用
r''expression''内部的字符串默认不转义，'''...'''的格式表示多行内容。
2.2 字符串与编码
-
计算机系统通用的字符编码工作方式：字符编码
-
Python的字符串：在最新的Python 3版本中，字符串是以Unicode编码的，也就是说，Python的字符串支持多语言。Python的文本在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。
#以Unicode表示的str通过encode()方法可以编码为指定的bytes：
>>>'ABC'.encode('ascii')
b'ABC'
>>> '中文'.encode('utf-8')
b'\xe4\xb8\xad\xe6\x96\x87'
#含有中文的str无法用ASCII编码，因为中文编码的范围超过了ASCII编码的范围，Python会报错:
>>> '中文'.encode('ascii')
Traceback (most recent call last):
File "" , line 1, in <module>
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-1: ordinal not in range(128)
#如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法:
>>> b'ABC'.decode('ascii')
'ABC'
>>> b'\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8')
'中文'
重点： 由于Python源代码也是一个文本文件，所以，当源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；
第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。
- 格式化
- 与C语言是一样，用%实现：
>>>print('%2d-%02d' % (3, 1))
3-01
>>>print('%.2f' % 3.1415926)
3.14
- 使用字符串的format()方法，不过这种方式写起来比%要麻烦得多：
>>> 'Hello, {0}, 成绩提升了 {1:.1f}%'.format('小明', 17.125)
'Hello, 小明, 成绩提升了 17.1%'
2.3 list 和tuple
- list[]列表：有序的集合，可以随时添加和删除其中的元素
#追加追加元素到末尾
>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']
#把元素插入到指定的位置
>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']
#删除list末尾的元素
>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']
#把某个元素替换成别的元素，可以直接赋值给对应的索引位置
>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']
- tuple()元组：tuple和list非常类似，但是tuple一旦初始化就不能修改
#只有1个元素的tuple定义时必须加一个逗号,，来消除歧义
>>> t = (1,)
>>> t
(1,)
理解tuple所谓的“不变”：tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的
>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])
2.4 条件判断: if, elif, else
注意：条件判断从上向下匹配，当满足条件时执行对应的块内语句
2.5 循环
- for x in …循环：把每个元素代入变量x，然后执行缩进块的语句。
- while循环：只要条件满足，就不断循环，条件不满足时退出循环。
- break：提前结束循环。
- continue：跳过当前的这次循环，直接开始下一次循环。
n = 0
while n < 10:
n = n + 1
if n % 2 == 0: # 如果n是偶数，执行continue语句
continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
print(n)
2.6 dic字典和set集合
1.dic{} 原理：给定一个名字(key)，比如’Michael’，dict在内部就可以直接计算出Michael对应的存放成绩的“页码”，也就是95这个数字存放的内存地址，直接取出value来，所以速度非常快.
- dic.get(key): 查找key
- dic.pop(key): 删除key
2.set() 集合：一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
（Set）常用操作
重点：
- 不可变对象：对于不变对象来说（str,整数，tuple等），调用对象自身的任意方法，也不会改变该对象自身的内容。相反，这些方法会创建新的对象并返回，这样，就保证了不可变对象本身永远是不可变的。
- 哈希函数：讨论：关于哈希表
3.函数
3.1 定义函数
- 定义函数：使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
- 如果定义函数没有return语句，函数执行完毕后也会返回结果，只是结果为None。return None可以简写为return。
- 如果想定义一个什么事也不做的空函数，可以用pass语句。
def my_abs(x):
#如果有必要，可以先对参数的数据类型做检查；
if not isinstance(x, (int, float)):
raise TypeError('bad operand type')
if x >= 0:
return x
else:
return -x
注意：
- 在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数可以同时返回多个值，但其实就是一个tuple。
3.2 函数的参数
- 位置参数：调用函数时，传入的值按照位置顺序依次赋给参数。
- 默认参数：默认参数降低了函数调用的难度，但：
def add_end(L=[]):
L.append('END')
return L
这是因为Python函数在定义的时候，默认参数L的值就被计算出来了，即[]，因为默认参数L也是一个变量，它指向对象[]，每次调用该函数，如果改变了L的内容，则下次调用时，默认参数的内容就变了，不再是函数定义时的[]了。所以默认参数必须指向不变对象（str、none等）
- 可变参数：可变参数传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
#定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
- 关键字参数kw：关键字参数允许传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。
>>> def person(name, age, **kw):
print('name:', name, 'age:', age, 'other:', kw)
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {
'gender': 'M', 'job': 'Engineer'}
#可变参数类似，也可以先组装出一个dict，然后，把该dict转换为关键字参数传进去。
#试想你正在做一个用户注册的功能，除了用户名和年龄是必填项外，其他都是可选项，利用关键字参数来定义这个函数就能满足注册的需求。
>>> extra = {
'city': 'Beijing', 'job': 'Engineer'}
>>> person('Jack', 24, **extra)
name: Jack age: 24 other: {
'city': 'Beijing', 'job': 'Engineer'}
- 命名关键字参数：用来限制关键字参数的名字，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
def person(name, age, *, city, job):
print(name, age, city, job)
>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer
# 如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：
def person(name, age, *args, city, job):
print(name, age, args, city, job)
4. 高级特性
4.1 迭代
给定一个list或tuple，通过for循环来遍历这个list或tuple，这种遍历称为迭代（Iteration）。
#只要是可迭代对象，无论有无下标，都可以迭代，比如dict就可以迭代
>>> d = {
'a': 1, 'b': 2}
>>> for key in d:
... print(key)
...
a
c
- dic迭代：默认情况下，dict迭代的是key。如果要迭代value，可以用for value in d.values()，如果要同时迭代key和value，可以用for k, v in d.items()。
- enumerate函数可以把一个list变成索引-元素对，这样就可以在for循环中同时迭代索引和元素本身：
>>> for i, value in enumerate(['A', 'B', 'C']):
... print(i, value)
...
0 A
1 B
2 C
- 判断对象是否可迭代：通过collections模块的Iterable类型。一般来说，str、list、dic等都可以迭代，整数等不可以迭代。
4.2 列表生成式
#使用两个变量来生成list
>>> d = {
'x': 'A', 'y': 'B', 'z': 'C' }
>>> [k + '=' + v for k, v in d.items()]
['y=B', 'x=A', 'z=C']
注意：for前面的if … else是表达式，没有else 会报错；而for后面的if是过滤条件，不能带else。
>>> [x if x % 2 == 0 else -x for x in range(1, 11)]
[-1, 2, -3, 4, -5, 6, -7, 8, -9, 10]
>>> [x for x in range(1, 11) if x % 2 == 0]
[2, 4, 6, 8, 10]
4.3 生成器（generator）
一边循环一边计算的机制，称为生成器：generator
创建方法：
1.把一个列表生成式的[]改成()，就创建了一个generator
>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x1022ef630>
调用：next(g)：每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。或者使用for循环，因为generator也是可迭代对象。
2.如果推算的算法比较复杂，用类似列表生成式的for循环无法实现的时候，还可以用函数来实现。这时候只需要把函数变成generator，即把print(values)改为yield values就可以了：
def fib(max):
n, a, b = 0, 0, 1
while n < max:
yield b
a, b = b, a + b
n = n + 1
return 'done'
注意：1. 函数是顺序执行，遇到return语句或者最后一行函数语句就返回。而变成generator的函数，在每次调用next()的时候执行，遇到yield语句返回，再次执行时从上次返回的yield语句处继续执行。
2. for循环调用generator时，发现拿不到generator的return语句的返回值。如果想要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中：
>>> g = fib(6)
>>> while True:
... try:
... x = next(g)
... print('g:', x)
... except StopIteration as e:
... print('Generator return value:', e.value)
... break
...
g: 1
g: 1
g: 2
g: 3
g: 5
g: 8
Generator return value: done