python学习（1）

参考https://www.liaoxuefeng.com/wiki/1016959663602400

python环境

1. 计算机命令模式下的python交互模式

①在命令行模式下敲命令python，就看到类似如下的一堆文本输出，然后就进入到Python交互模式，它的提示符是>>>，输入exit()即可退出。适用于一行或几行比较简短的python的运行
②命令模式下，在.py存储的文件夹下即可运行python程序。适用与python程序文件.py的运行

2、python文本编辑器
在python交互环境下的代码在环境关闭后示无法生成.py文件保存的，因此，可以利用文本编辑器生成.py文件，再到命令模式下运行。
文本编辑器可以考虑使用Visual Studio Code，免费，且有中英日韩等多种语言选择，超好用！！！
3.python代码运行助手
网页编辑运行

python基础

1. python的输入输出
   input()与print()函数来实现输入输出，程序块需要进行缩进，每级缩进量为4个空格。
2. 数据类型和变量
   整数型
   二进制、八进制、十进制
   Python允许在数字中间以_分隔，因此，写成10_000_000_000和10000000000是完全一样的。十六进制数也可以写成0xa1b2_c3d4。
   浮点型
   Python允许在数字中间以_分隔，因此，写成10_000_000_000和10000000000是完全一样的。十六进制数也可以写成0xa1b2_c3d4。Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）。
   字符串
   字符串是以单引号’或双引号"括起来的任意文本，比如’abc’，“xyz"等等。请注意，’'或”“本身只是一种表示方式，不是字符串的一部分，因此，字符串’abc’只有a，b，c这3个字符。如果’本身也是一个字符，那就可以用”"括起来，比如"I’m OK"包含的字符是I，’，m，空格，O，K这6个字符。
   如果字符串内部既包含’又包含"怎么办？可以用转义字符\来标识，比如：

'I’m “OK”!'其内容为I’m “OK”!

\n表示换行，\t表示制表符，字符\本身也要转义，所以\表示的字符就是\。
Python还允许用r’‘表示’'内部的字符串默认不转义，

print(’\\t\’)
\ \

print(r’\\t\’)
\\t\

Python允许用’’’…’’'的格式表示多行内容，

print(’’‘line1
… line2
… line3’’’)
line1
line2
line3

多行字符串’’’…’’'还可以在前面加上r使用。
布尔值
一个布尔值只有True、False两种值，要么是True，要么是False。布尔值可以用and、or和not运算。布尔值经常用在条件判断中。

3 > 2
True

空值
用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值。
变量
变量不仅可以是数字，还可以是任意数据类型。
变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头。
变量本身类型不固定的语言称之为动态语言，与之对应的是静态语言。静态语言在定义变量时必须指定变量类型，如果赋值的时候类型不匹配，就会报错。例如Java是静态语言，赋值语句如下（// 表示注释）：
int a = 123; // a是整数类型变量
a = “ABC”; // 错误：不能把字符串赋给整型变量
常量
所谓常量就是不能变的变量，比如常用的数学常数π就是一个常量。在Python中，通常用全部大写的变量名表示常量：
PI = 3.14159265359
整数的地板除//永远是整数，即使除不尽。要做精确的除法，使用/就可以。
因为//除法只取结果的整数部分，所以Python还提供一个余数运算%。
6. 字符串和编码
python支持多种编码语言，最好用的是“可变长编码”的UTF-8编码，当源程序中有中文时，在开头需添加：
#!/usr/bin/env python3
#-- coding: utf-8 -
第一行注释是为了告诉Linux/OS X系统，这是一个Python可执行程序，Windows系统会忽略这个注释；
第二行注释是为了告诉Python解释器，按照UTF-8编码读取源代码，否则，你在源代码中写的中文输出可能会有乱码。
申明了UTF-8编码并不意味着你的.py文件就是UTF-8编码的，必须并且要确保文本编辑器正在使用UTF-8 without BOM编码。
字符串
对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符：

ord(‘A’)
65

ord(‘中’)
20013

chr(66)
‘B’

如果知道字符的整数编码，还可以用十六进制这么写str：

‘\u4e2d\u6587’
‘中文’

由于Python的字符串类型是str，在内存中以Unicode表示，一个字符对应若干个字节。如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。
Python对bytes类型的数据用带b前缀的单引号或双引号表示：x = b’ABC’
要注意区分’ABC’和b’ABC’，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。
以Unicode表示的str通过encode()方法可以编码为指定的bytes，例如：

‘ABC’.encode(‘ascii’)
b’ABC’

反过来，如果我们从网络或磁盘上读取了字节流，那么读到的数据就是bytes。要把bytes变为str，就需要用decode()方法：

b’ABC’.decode(‘ascii’)
‘ABC’

b’\xe4\xb8\xad\xe6\x96\x87’.decode(‘utf-8’)
‘中文’

要计算str包含多少个字符，可以用len()函数：

len(‘ABC’)
3

格式化
在Python中，采用的格式化方式和C语言是一致的，用%实现，举例如下：

‘Hello, %s’ % ‘world’
‘Hello, world’

‘Hi, %s, you have $%d.’ % (‘Michael’, 1000000)
‘Hi, Michael, you have $1000000.’

%d整数，%s字符串，%f浮点数，%x十六进制整数
print(’%.2f’ % 3.1415926)》3.14
如果你不太确定应该用什么，%s永远起作用，它会把任何数据类型转换为字符串，需要转义，用%%来表示一个%。

‘growth rate: %d %%’ % 7

另一种格式化字符串的方法是使用字符串的format()方法，它会用传入的参数依次替换字符串内的占位符{0}、{1}……，

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

最后一种格式化字符串的方法是使用以f开头的字符串，称之为f-string，它和普通字符串不同之处在于，字符串如果包含{xxx}，就会以对应的变量替换

r = 2.5
s = 3.14 * r ** 2
print(f’The area of a circle with radius {r} is {s:.2f}’)
The area of a circle with radius 2.5 is 19.62

7. list和tuple
   list[]
   Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。

classmates = [‘Michael’, ‘Bob’, ‘Tracy’]
classmates
[‘Michael’, ‘Bob’, ‘Tracy’]

用len()函数可以获得list元素的个数，用索引来访问list中每一个位置的元素，记得索引是从0开始的：

classmates[0]
‘Michael’

如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：

classmates[-1]
‘Tracy’

以此类推，可以获取倒数第2个、倒数第3个。list是一个可变的有序表，所以，可以往list中追加元素到末尾：

classmates.append(‘Adam’)
classmates
[‘Michael’, ‘Bob’, ‘Tracy’, ‘Adam’]

也可以把元素插入到指定的位置，比如索引号为1的位置：

classmates.insert(1, ‘Jack’)
classmates
[‘Michael’, ‘Jack’, ‘Bob’, ‘Tracy’, ‘Adam’]

要删除list末尾的元素，用pop()方法：

classmates.pop()
‘Adam’

classmates
[‘Michael’, ‘Jack’, ‘Bob’, ‘Tracy’]

要删除指定位置的元素，用pop(i)方法，其中i是索引位置：

classmates.pop(1)
‘Jack’

classmates
[‘Michael’, ‘Bob’, ‘Tracy’]

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

classmates[1] = ‘Sarah’
classmates
[‘Michael’, ‘Sarah’, ‘Tracy’]

list里面的元素的数据类型也可以不同，比如：

L = [‘Apple’, 123, True]

list元素也可以是另一个list，s可以看成是一个二维数组，比如：

s = [‘python’, ‘java’, [‘asp’, ‘php’], ‘scheme’]
len(s)
4

tuple（）
另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。比如同样是列出同学的名字：

classmates = (‘Michael’, ‘Bob’, ‘Tracy’)

如果要定义一个空的tuple，可以写成()：

t = ()
t
()

但是，要定义一个只有1个元素的tuple，如果你这么定义：

t = (1)
t
1

定义的不是tuple，是1这个数！这是因为括号()既可以表示tuple，又可以表示数学公式中的小括号，这就产生了歧义，因此，Python规定，这种情况下，按小括号进行计算，计算结果自然是1。
所以，只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

t = (1,)
t
(1,)

最后来看一个“可变的”tuple：

t = (‘a’, ‘b’, [‘A’, ‘B’])
t[2][0] = ‘X’
t[2][1] = ‘Y’
t
(‘a’, ‘b’, [‘X’, ‘Y’])

表面上看，tuple的元素确实变了，但其实变的不是tuple的元素，而是list的元素。tuple一开始指向的list并没有改成别的list，所以，tuple所谓的“不变”是说，tuple的每个元素，指向永远不变。即指向’a’，就不能改成指向’b’，指向一个list，就不能改成指向其他对象，但指向的这个list本身是可变的！
9. 条件判断
if-elif-else语句
if<条件1>:
<执行1>
elif<条件2>:
<执行2>
else:
<执行3>
要注意冒号：和程序块缩进.
if语句执行有个特点，它是从上往下判断，如果在某个判断上是True，把该判断对应的语句执行后，就忽略掉剩下的elif和else，下面的程序打印的是teenager：
age = 20
if age >= 6:
print(‘teenager’)
elif age >= 18:
print(‘adult’)
else:
print(‘kid’)
10.循环
for循环：
sum = 0
for x in range(101):
sum = sum + x
print(sum)
range()函数，可以生成一个整数序列，再通过list()函数可以转换为list。比如range(5)生成的序列是从0开始小于5的整数
while循环：
只要条件满足，就不断循环，条件不满足时退出循环。
sum = 0
n = 99
while n > 0:
sum = sum + n
n = n - 2
print(sum)
break
在循环中，break语句可以提前退出循环
continue
跳过当前的这次循环，直接开始下一次循环。
11. dict和set
dict{}
Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。

d = {‘Michael’: 95, ‘Bob’: 75, ‘Tracy’: 85}
d[‘Michael’]
95

由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉。要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：

‘Thomas’ in d
False

二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：

d.get(‘Thomas’)
d.get(‘Thomas’, -1)
-1

注意：返回None的时候Python的交互环境不显示结果。
要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

d.pop(‘Bob’)
75

d
{‘Michael’: 95, ‘Tracy’: 85}

请务必注意，dict内部存放的顺序和key放入的顺序是没有关系的。dict的key必须是不可变对象。
set
set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
要创建一个set，需要提供一个list作为输入集合：

s = set([1, 3, 2，2])
s
{1, 2, 3}

注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果。通过remove(key)方法可以删除元素。

python函数

1. 调用函数
   函数名（参数）
   Python内置的常用函数还包括数据类型转换函数，比如int()函数可以把其他数据类型转换为整数：

int(‘123’)
123

2. 定义函数
   在Python中，定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回。
   我们以自定义一个求绝对值的my_abs函数为例：
   def my_abs(x):
   if x >= 0:
   return x
   else:
   return -x
   空函数
   如果想定义一个什么事也不做的空函数，可以用pass语句：
   def nop():
   pass
   pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。
   pass还可以用在其他语句里，比如：
   if age >= 18:
   pass
   缺少了pass，代码运行就会有语法错误。
   参数检查
   返回多个值
   import math
   def move(x, y, step, angle=0):
   nx = x + step * math.cos(angle)
   ny = y - step * math.sin(angle)
   return nx, ny
   import math语句表示导入math包，并允许后续代码引用math包里的sin、cos等函数。
   然后，我们就可以同时获得返回值：

x, y = move(100, 100, 60, math.pi / 6)
print(x, y)
151.96152422706632 70.0

但其实这只是一种假象，Python函数返回的仍然是单一值：

r = move(100, 100, 60, math.pi / 6)
print®
(151.96152422706632, 70.0)

返回值是一个tuple！但是，在语法上，返回一个tuple可以省略括号，而多个变量可以同时接收一个tuple，按位置赋给对应的值，所以，Python的函数返回多值其实就是返回一个tuple，但写起来更方便。
4. 函数的参数
位置参数
对于power(x)函数，参数x就是一个位置参数。
当我们调用power函数时，必须传入有且仅有的一个参数x。
默认参数
对def power(x, n=2)，n即为默认参数，调用power（5）就相当于power（5，2），power（5，3）时，n=3.
定义默认参数要牢记一点：默认参数必须指向不变对象！！！def add_end(L=None):代替def add_end(L=[]):
可变参数*s
可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
关键字参数
关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict。请看示例：

def person(name, age, **kw):
print(‘name:’, name, ‘age:’, age, ‘other:’, kw)
person(‘Bob’, 35, city=‘Beijing’)
name: Bob age: 35 other: {‘city’: ‘Beijing’}

person(‘Adam’, 45, gender=‘M’, job=‘Engineer’)
name: Adam age: 45 other: {‘gender’: ‘M’, ‘job’: ‘Engineer’}

命名关键字参数
只接收city和job作为关键字参数。这种方式定义的函数如下：

def person(name, age, , city, job):
print(name, age, city, job)
和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符，*后面的参数被视为命名关键字参数。
调用方式如下：

person(‘Jack’, 24, city=‘Beijing’, job=‘Engineer’)
Jack 24 Beijing Engineer
如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了：

def person(name, age, *args, city, job):
print(name, age, args, city, job)
命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：

person(‘Jack’, 24, ‘Beijing’, ‘Engineer’)
Traceback (most recent call last):
File “”, line 1, in
TypeError: person() takes 2 positional arguments but 4 were given

由于调用时缺少参数名city和job，Python解释器把这4个参数均视为位置参数，但person()函数仅接受2个位置参数。
命名关键字参数可以有缺省值，从而简化调用：

def person(name, age, *, city=‘Beijing’, job):
print(name, age, city, job)

由于命名关键字参数city具有默认值，调用时，可不传入city参数：

person(‘Jack’, 24, job=‘Engineer’)
Jack 24 Beijing Engineer

参数组合
在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。
6. 递归函数
在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。

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

使用递归函数需要注意防止栈溢出。在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。
解决递归调用栈溢出的方法是通过尾递归优化，事实上尾递归和循环的效果是一样的，所以，把循环看成是一种特殊的尾递归函数也是可以的。
尾递归是指，在函数返回的时候，调用自身本身，并且，return语句不能包含表达式。这样，编译器或者解释器就可以把尾递归做优化，使递归本身无论调用多少次，都只占用一个栈帧，不会出现栈溢出的情况。