python程序设计基础_python程序设计基础目录博客

第一章 基础知识

1.1python是一种怎样的语言

python是一门跨平台、开源、免费的解释型高级动态编程语言，支持伪编译将python源程序转换为字节码来优化程序和提高运行速度，支持使用py2exe、pyinstaller或cx_Freeze工具将python程序转换为二进制可执行文件。

python支持命令编程、函数式编程，完全支持面向对象程序设计，语法简洁清晰，拥有大量的几乎支持所有领域应用开发的成熟扩展库。

胶水语言：可以把多种不同语言编写的程融合走到一起实现无缝拼接，更好地发挥不同语言和工具的优势，满足不同领域的需求。

几个重要网址

> https://www.python.org/

> https://www.python.org/doc/

> http://bugs.python.org/

> https://hackerone.com/python

> http://stackoverflow.com/questions/tagged/python

默认编程环境:

IDLE

 其他常用开发环境:

> Eclipse+PyDev

> pyCharm

> wingIDE

> Eric

> PythonWin

> Anaconda  默认安装带了大量扩展库

---

1.2IDLE的使用

在IDLE中,如果使用交互式编程模式,那么直接在提示符“>>>”后面输入相应的命令并回车执行即可,如果执行顺利的话,马上就可以看到执行结果,否则会抛出异常。

在IDLE界面中使用菜单“File” == >“New File”创建一个程序文件,输入代码并保存为.py或.pyw文件。

使用菜单“Run” == >“CheckModule”来检查程序中是否存在语法错误,或者使用菜单“Run” == >“Run Module”运行程序,程序运行结果将直接显示在IDLE交互界面上。

在有些情况下可能需要在命令提示符环境中运行Python程序文件。在“开始”菜单的“附件”中单击“命令提示符”,然后执行Python程序。假设有程序HelloWorld.py内容如下。

进入cmd模式，cd进入文件。dir查看文件，python 文件名称（HelloWorld.py），执行文件

找到要执行的文件，在此界面按住shift和鼠标右键，找到在此处打开命令窗口，然后输入python 要执行的文件名（HelloWorld.py），python解释器界面会输出被执行文件的内容。

快捷键

---

1.3使用pip管理第三方包

pip工具常用命令

pip download SomePackage [=version]        下载扩展库的指定版本（不写默认最新版本），不安装

pip freeze [> requirements.txt]                       以requirements的格式列出已安装模块

pip list                                                             列出当前已安装的所有模块

pip install SomePackage [=version]               在线安装SomePackage模块的指定版本

pip install SomePackage.whl                        通过whl文件离线安装扩展库

pip install package1 package2 . . .                 依次在线安装package1、package2等扩展模块

pip install -r requirements.txt                          安装requirements.txt文件中指定的扩展库

pip install --upgrade SomePackage               升级SomePackage模块

pip uninstall SomePackzge [=version]            卸载SomePackage模块的指定版本

pip命令的使用

找到python安装的路径，找到python文件下的Scripts文件，按Shift+鼠标右击，选在此处打开命令，即可执行上面的pip命令。

---

1.4python的对象模型

对象是python语言中修基本的概念，在python中处理的一切都是对象。python中有许多内置对象可供编程者使用，内置对象可直接使用，如文字、字符串、列表、del等；非内置对象（标准库、扩展库）需要导入模块才能使用，如正弦函数sin(x)，随机数产生函数random()。

python常见的内置对象

数字：整数、实数、虚数

字符串：单引号、双引号、三引号；原始字符串的含义是里面的转义字符不转义了

列表：[]

字典：字典的键不能重复，必须是不可变的对象（必须是可华哈希的）

元组：（3，）

元组是不可变的，是可哈希的；列表是可变的，是不可哈希的。因此，元组可以作为字典的键，列表不可以作为字典的键。

集合：{}，里面元素是不可变的，不可重复

惰性求值的特点：跟它要它才会给你，给过你的就不会再给你（已经访问过的元素就没法在访问了）

python变量

在python中，不需要事先声明变量名及其类型，直接赋值即可创建各种类型的对象变量。这一点适用于python任意类型的对象。

例如语句

>>>x=3

创建了整型变量x，并赋值为3，再例如语句

>>>x='Hello World.'

创建了字符串变量x，并赋值为‘Hello World.’。

python属于强类型编程语言，python解释器会根据赋值或运算来自动推断变量类型。python还是一种动态类型语言，变量的类型也是可以随时变化的。

>>>x=3

>>>print(type(x))    #查看变量类型

<class 'int'>            #整型

>>>x='Hello World.'

>>>print(type(x))

<class 'str'>            #字符串类型

>>>x=[1,2,3]

>>>print(type(x))

<class 'list'>              #列表类型

 #测试对象是否是某个类型的实例

>>>isinstance(3,int)                    #测试3是不是整型的一个实例

True

>>>isinstance('Hello world',str)  #测试‘HelloWorld’是不是字符串的一个实例

True

如果变量出现在赋值运算符或复合赋值运算符（例如+=、*=等等）的左边则表示创建变量或者修改变量的值，否则表示引用该变量的值，这一点同样适用于使用下标来访问列表、字典等可变序列以及其他自定义对象中元素的情况。 

>>>x=3              #创建整型变量

>>>print(x**2)

9

>>>x+=6           #修改变量值

>>>print(x)        #读取变量值并输出显示

9

>>>x=[1,2,3]      #创建列表对象

>>>x[1]=5          #修改列表元素值

>>>print(x)        #输出显示整个列表

[1,5,3]

>>>print(x[2])    #输出显示列表指定元素

3

字符串和元组属于不可变序列，不能通过下标的方式来修改其中的元素值，试图修改元组中元素的值时会抛出异常。

>>>x=(1,2,3)
>>>print(x)
(1, 2, 3)

>>>x[1]=5   #修改元组中下标为1的元素值

Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    x[1]=5
TypeError: 'tuple' object does not support item assignment

在python中，允许多个变量指向同一值，例如

>>>x=3
>>>id(x)
1607915602224

>>>y=x
>>>id(y)
1607915602224

然而，当为其中一个变量修改值后，其内存地址将会变化，但这并不影响另一个变量，例如接着上面的代码再继续执行下面的代码：

>>>x+=6
>>>id(x)
1607915602416

>>>y
3

>>>id(y)
1607915602224

python采用的是基于值的内存管理方式，如果为不同变量赋值为相同值，这个值在内存中只有一份，多个变量之指向同一块内存地址。

>>>x=3
>>>id(x)
1607915602224

>>>y=3
>>>id(y)
1607915602224

>>>x=[1,1,1,1]
>>>id(x[0])==id(x[1])
True

python具有自动内存管理功能，对于没有任何变量指向的值，python自动将其删除。python会跟踪所有的值，并自动删除不再有变量指向的值。因此，python程序员一般情况下不需要太考虑内存管理的问题。

尽管如此，显示使用del命令删除不需要的值或显示关闭不再需要访问的资源，仍是一个好的习惯，同时也是一个优秀程序员的基本素养之一。

定义变量名

• 变量名必须以字母或下划线开头，但以字下划线开头的变量在python中特殊含义；
• 变量名中不能有空格以及标点符号（括号、引号、逗号、斜线、反斜线、冒号、句号、问号等等）；
• 不能使用关键字作变量名，可以导入keyword模板后使用print(keyword.kwlist)查看所有python关键字；
• 不建议使用系统内置的模块名、类型名或函数名以及已导入的模块名及其成员名作为变量，这将会改变其类型和含义，可以通过dir（_builtins_）查看所有的内置模块、类型和函数；
• 变量名对英文字母的大小写敏感，例如student和Student是不同的变量；

数字

数字是不可变对象，可以表示任意大小的数字

>>>a=99999999999999999999a=99999999999999999999999999999999
>>>a*a
9999999999999999999999999999999800000000000000000000000000000001

>>>a**3
999999999999999999999999999999970000000000000000000000000000000299999999999999999999999999999999

python的IDEL交互界面可以当做简便计算器来使用。

>>>((3**2)+(4**2))**0.5
5.0

python中的整数类型可以分为：

十进制整数

如：0、-1、9、123

十六进制整数

需要16个数字0、1、2、3、4、5、6、7、8、9、a、b、c、d、e、f来表示整数，必须以0x开头，如0x10、0xfa、0xabcdef

八进制整数

只需要8个数字0、1、2、3、4、5、6、7来表示整数，必须以0o开头，如：0o35、0o11

二进制整数

只需要2个数字0、1来表示整数，必须以0b开头，0b101、0b100

浮点数又称小数

15.0、0.37、-11.2、1.2e2（1.2*10的2次方）、314.15e-2（314.15*10的-2次方）

python内支持复数类型

>>>a=3+4j
>>>b=5+6j
>>>c=a+b
>>>c
(8+10j)

>>>c.real                    #查看复数实部
8.0

>>>c.imag                    #查看复数虚部
10.0

>>>a.conjugate()          #返回共轭复数
(3-4j)

>>>a*b                        #复数乘法
(-9+38j)

>>>a/b                         #复数除法
(0.6393442622950819+0.03278688524590165j)

字符串

用单引号、双引号或三引号括起来的符号系列称为字符串。

单引号、双引号、三单引号、三双引号可以互相嵌套，用来表示复杂字符串

'abc'、‘123’、‘中国’、"python"、''' Tom said,''Let's go'' '''

字符串属于不可变序列

空串表示为''或''''

三引号'''或''''''表示的字符串可以换行，支持排版较为复杂的字符串；三引号还可以在程序中表示较长的注释

字符串合并

a='abc'+'123'       #生成新对象
a
'abc123'

 字符串格式化

>>>a=3.6674
>>>'%7.3f'%a           #%前是格式，格式中%是引导符；把a以浮点数的形式显示出来，这个浮点数的总长度是7，小数位数是3
'  3.667'                     #3.667不够7位，前面用空格填充

>>>"%d:%c"%(65,65)       #将括号中第一个65以整数的格式，第二个65以字符的格式显示
'65:A'

>>>"""My name is %s,and my age is %d"""%('Dong Fuguo',39)
'My name is Dong Fuguo,and my age is 39'
 

常用转义字符

转义字符用法

>>>print('Hello\nWorld!')                             #包含转义字符的字符串
Hello
World!

>>>print('\101')                                           #三位八进制数对应的字符
A

>>>print('\x41')                                           #两位十六进制数对应的字符
A

>>>print('我是\u8463\u4ed8\u56fd')          #四位十六进制书表示的Unicode字符
我是董付国

#ord() :可返回一个字符的序数，英文字母或数字的ASCII码，返回的是一个十进制数

#hex()：将十进制数转换成十六进制数

字符串界定符前面加字母r（R）表示原始字符串，其中的特殊字符不进行转义，但字符串的最后一个字符不能是\。原始字符串主要用于正则表达式、文件路径或者URL的场合。

>>>path='C:\Windows\notepad.exe'
>>>print(path)                                               #字符\n被转义为换行符
C:\Windows
otepad.exe

>>>path=r'C:\Windows\notepad.exe'           #原始字符串，任何字符都不敢转义
>>>print(path)
C:\Windows\notepad.exe

运算符和表达式

+运算符

除了用于算数加减法以外，还可以用于列表、元组、字符串的连接，但不支持不同类型的对象之间相加或连接。

>>>[1,2,3]+[4,5,6]                      #连接两个列表
[1, 2, 3, 4, 5, 6]

>>>(1,2,3)+(4,)                           #连接两个元组
(1, 2, 3, 4)

>>>'abcd'+'1234'                        #连接两个字符
'abcd1234'

>>>'A'+1                                           #不支持字符与数字相加，抛出异常
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in <module>
    'A'+1
TypeError: can only concatenate str (not "int") to str

>>>True+3                                 #python内部把True当作1处理
4

>>>False+3                                 #python内部把False当作0处理
3

*运算符

逼近可以用于数值乘法，还可以用于列表、字符串、元组等类型，当列表、字符串或元组等类型变量与整数进行“*”运算时，表示对内容进行重复并返回重复后的新对象。

>>>2.0*3                                #浮点数与整数相乘
6.0

>>>(3+4j)*2                            #复数与整数相乘
(6+8j)

>>>(3+4j)*(3-4j)                       #复数与复数相乘
(25+0j)

>>>"a"*10                                #字符串重复
'aaaaaaaaaa'

>>>[1,2,3]*3                             #列表重复
[1, 2, 3, 1, 2, 3, 1, 2, 3]            #生成的是一个新列表，对原来的列表不会有影响

>>>(1,2,3)*3                             #元组重复
(1, 2, 3, 1, 2, 3, 1, 2, 3)

/和//运算符

python中的除法有两种，“/”和“//”分别表示除法和整除运算，并且python 2.x和python 3.x对“/”运算符的解释也略有区别。在python 3.10中运算结果如下：

>>>3/5
0.6

>>>3//5                 #取整，向下取整，一个横着放的数轴向左边取整数
0

>>>3.0/5
0.6

>>>3.0//5               #操作数中有实数，结果是有实数的整数
0.0

>>>13//10
1

>>>-13//10              #向下取整
-2

%运算符

除去可以用于字符串格式化之外，还可以对整数和浮点数计算余数。但是由于浮点数的精确度影响，计算结果可能略有误差。

>>>3.1%2
1.1

>>>6.3%2.1
2.0999999999999996          #实数在python中有精度偏差

>>>6%2
0

>>>6.0%2
0.0

>>>6.0%2.0
0.0

>>>5.7%4.8
0.9000000000000004

关系运算符可以连用

>>>1<3<5                                            #等价于1<3 and 3<5
True

>>>'Hello'>'world'                                #比较字符串大小           前面都一样长的大
False                                                   #比较第一个字符，比较不出来比较第二个，以此类推

>>>[1,2,3]<[1,2,4]                              #比较列表大小
True

>>>'Hello'>3                                      #字符串和数字不能比较
Traceback (most recent call last):
  File "<pyshell#27>", line 1, in <module>
    'Hello'>3
TypeError: '>' not supported between instances of 'str' and 'int'

>>>{1,2,3}<{1,2,3,4}                          #测试是否子集
True

in

成员测试运算符

用于成员测试，即测试一个对象是否为另一个对象的元素。

>>>3 in [1,2,3]                     #测试3是否存在于列表[1,2,3]中
True

>>>5 in range(1,10,1)        #range()是用来生成指定范围数字的内置函数
True                                   #range（开始，结束，步长），左闭右开区间

>>>'abc' in 'abcdef'            #子字符串测试
True

>>>for i in (3,5,7):             #循环，成员遍历
    print(i,end='\t')               #默认换行，\t制表符
3    5    7

is

同一性测试运算符(identity comparison)

用来测试两个对象是否是同一个，如果是则返回True，否则返回False。如果两个对象是同一个，二者具有相同的内存地址。

>>>3 is 3
True

>>>x=[300,300,300]
>>>x[0] is x[1]                 #基于值的内存管理，同一个值在内存中只有一份
True

>>>x=[1,2,3]
>>>y=[1,2,3]
>>>x is y                       #上面形式创建的x和y不是同一个列表对象
False

位运算符

只能用于整数，其内部执行过程为：首先将整数转换二进制数，然后右对齐，必要的时候左侧补0，按位进行运算，最后再把计算结果转换为十进制数字返回。

>>>3 << 2            #把3左移2位
12                         #3*4

>>>3 & 7             #位与运算   只有1和1得1，剩下都0
3

>>>3 | 8               #位或运算    有1则1
11

>>>3 ^ 5               #位异或运算   相同为0，不同为1
6

交集、并集、对称差集、差集

集合的交集、并集、对称差集等运算借助于位运算符来实现，而差集则使用减号运算符实现（注意，并集运算符不是加号）

>>>{1,2,3} | {3,4,5}         #并集，自动去除重复元素
{1, 2, 3, 4, 5}

>>>{1,2,3} & {3,4,5}      #交集，找共同元素
{3}

>>>{1,2,3} ^ {3,4,5}      #对称差集，你有我没有+我有你没有
{1, 2, 4, 5}

>>>{1,2,3} - {3,4,5}       #差集，前面集合-后面集合有得元素
{1, 2}

 逻辑运算符and和or

逻辑运算符and和or具有惰性求值特点（只计算必须要计算的值）

>>>3>5 and a>3                                       #注意，此时并没有变量a
False

>>>3>5 or a>3                                           #3>5的值为False，所以需要计算后面的表达式
Traceback (most recent call last):
  File "<pyshell#55>", line 1, in <module>
    3>5 or a>3
NameError: name 'a' is not defined

>>>3<5 or a>3                                          #3>5的值为True，不需要计算后面的表达式
True

>>>3 and 5                                               #最后一个计算的表达式的值作为整个表达的值
5

                 

>>>3 and 5>2                                           
True

>>>3 not in [1,2,3]                                   #逻辑非运算符not
False

>>>3 is not 5                                           #not的计算结果只能是True或False之一
True

矩阵相乘运算符@

python 3.5增加了一个新的矩阵相乘运算符@

逗号

并不是运算符，只是普通的分隔符

'a' in 'b' ,'a'
(False, 'a')

>>>'a' in ('b','a')         #():元组
True

>>>x=3,5                 #返回的是一个元组
>>>x

(3, 5)

>>>3==3,5
(True, 5)

>>>x=3+5,7
>>>x
(8, 7)

在python 中，单个任何类型的对象或常数属于合法表达式，使用运算符连接的变量和常量以及函数调用的任意组合也属于合法的表达式。

>>>a=[1,2,3]
>>>b=[4,5,6]
>>>c=a+b
>>>c
[1, 2, 3, 4, 5, 6]

>>>d=list(map(str,c))           #将map函数的值映射到list列表中
>>>d
['1', '2', '3', '4', '5', '6']

>>>import math
>>>list(map(math.sin,c))
[0.8414709848078965, 0.9092974268256817, 0.1411200080598672, -0.7568024953079282, -0.9589242746631385, -0.27941549819892586]

>>>'Hello'+' '+'world'
'Hello world'

>>>'welcome '*3
'welcome welcome welcome '

>>>('welcome,'*3).rstrip(',')+'!'          #rstrip：在右端删除特点的字符
'welcome,welcome,welcome!'

常用内置函数

（内置对象的一种）

内置函数不需要导入任何模块即可使用

执行下面的命令可以列出所有的内置函数

>>>dir(__builtins__)            #函数（对象）

常用内置函数简介

常用内置函数详解

dir()函数

可以查看指定模块中包含的所有成员或者指定对象类型所支持的操作。

help（）

函数则返回指定模块或函数䣌说明文档。

>>>import math
>>>dir(math)
['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']

>>>dir('a')
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

>>>help(math.sqrt)
Help on built-in function sqrt in module math:

sqrt(x, /)
    Return the square root of x.

>>>help(''.center)
Help on built-in function center:

center(width, fillchar=' ', /) method of builtins.str instance
    Return a centered string of length width.
    
    Padding is done using the specified fill character (default is a space).

>>>help(sum)
Help on built-in function sum in module builtins:

sum(iterable, /, start=0)
    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
    
    When the iterable is empty, return the start value.
    This function is intended specifically for use with numeric values and may
    reject non-numeric types.

ord（）和chr（）

是对功能相反的函数。ord（）用来返回单个字符的序数或unicode码；chr（）用来返回某序数对应的字符；str（）则直接将其任意类型参数转换为字符串。

>>>ord('a')
97

>>>chr(ord('A')+1)
'B'

>>>str(1)
'1'

>>>str(1234)
'1234'

>>>str([1,2,3])
'[1, 2, 3]'

>>>str((1,2,3))
'(1, 2, 3)'

>>>str({1,2,3})         #集合
'{1, 2, 3}'

>>>str(1)
'1'

>>>int(str(1))
1

>>>int(str(1234))
1234

>>>str([1,2,3,4])
'[1, 2, 3, 4]'

>>>list(str([1,2,3,4]))         #用list将字符串变成列表是不可以的，会把[]也加进去。要用eval
['[', '1', ',', ' ', '2', ',', ' ', '3', ',', ' ', '4', ']']

>>>eval(str([1,2,3,4]))
[1, 2, 3, 4]

max（）、min（）、sum（）

这三个内置函数分别用于计算列表、元组或其他可以迭代对象中所有元素最大值、最小值以及所有元素的之和，sum（）要求元素支持加法运算，max（）和min（）则要求序数或可迭代对象中的元素之间可比较大小。

>>>import random
>>>a=[random.randint(1,100) for i in range(10)]    #1-100之间随机得到一个整数，左闭右闭，从中选择一个数字，重复10次
>>>a                                                                      #a是拥有10个随机数的列表
[97, 41, 5, 51, 41, 87, 39, 78, 30, 28]
>>>print(max(a),min(a),sum(a))                           #查看a中的最大值、最小值和所有元素之和
97 5 497

>>>sum(a)/len(a)                                                 #计算列表中所有元素平均值
49.7

内置函数max（）和min（）的key参数可以用来指定比较规则

>>>x=['21','1234','9']        
>>>max(x)                   #字符串的最大值，先比第一个字符
'9'

>>>max(x,key=len)     #比较的规则是长度
'1234'

>>>max(x,key=int)     #比较的规则是先变成整数，然后比较大小
'1234'

type（）和isinstance（）

内置函数type（）和isinstance（）可以判断数据类型

>>>type([3])                                             #查看[3]的类型
<class 'list'>

>>>type({3}) in (list,tuple,dict)                  #判断{3}是否为列表，元组或字典类型的实例
False

>>>isinstance(3,int)    #测试一个对象是不是一个类型的实例  #判断3是否为int类型的实例
True

>>>isinstance(3j,(int,float,complex))       #判断3j是否为整型，浮点型或复数类型
True

sorted（）和reversed（）

sorted（）对列表、元素、字典、集合或者其他可迭代对象进进行排序返回新列表，reversed（）对可迭代对象（生成器对象和具有惰性求值特性的zip、map、filter、enumerate等类似对象除外）进行翻转（首尾交换）并返回可迭代对象reversed对象。

>>>x=['aaaa','bc','d','b','ba']
>>>sorted(x,key=lambda item:(len(item),item))      #对x进行排序，排序的规则是一个表达式：函数的参数：函数的返回值（参数长度，参数自己）

                                                                                #先按长度排序，长度一样的正常排序
['b', 'd', 'ba', 'bc', 'aaaa']

>>>reversed(x)               #reversed生成的是一个新对象，不是对之前的对象进行操作

                                       #逆序，返回reversed对象（可迭代）
<list_reverseiterator object at 0x000001C4C9DCDE40>

>>>list(reversed(x))        #用list把对象转化成列表可以查看里面有什么内容  #一般不这么用
['ba', 'b', 'd', 'bc', 'aaaa']

enumerate（）函数

用来枚举可迭代对象中的元素，返回可迭代的enumerate对象，其中每个元素都是包含索引和值的元组。

>>>list(enumerate('abcd'))                                   #枚举字符串中的元素
[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

>>>list(enumerate(['Python','Greate']))                 #枚举列表中的元素
[(0, 'Python'), (1, 'Greate')]

>>>list(enumerate({'a':97,'b':98,'c':99}.items()))    #枚举字典中的元素

                                                                              #items：返回字典中的所有项
[(0, ('a', 97)), (1, ('b', 98)), (2, ('c', 99))]

>>>for index,value in enumerate(range(10,15)):   #枚举range对象中的元素
    print((index,value),end='')

    
(0, 10)(1, 11)(2, 12)(3, 13)(4, 14)

内置函数map（）

把一个函数func依次映射到序列或迭代器对象的每个元素上，并返回一个可迭代的map对象作为结果，map对象中每个元素是原序列中元素经过函数func处理的结果。

>>>list(map(str,range(5)))    #把转换成字符串的方式映射到range（5）中
['0', '1', '2', '3', '4']

>>>def add5(v):                 #接收一个参数，将接收到的参数+5
    return v+5

>>>list(map(add5,range(10)))       #将range（10）中的所有数全部+5
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]

>>>def add(x,y):                           #接收两个参数，返回这两个参数的和
    return x+y

>>>list(map(add,range(5),range(5,10)))       #把双参数函数映射到两个序列上
[5, 7, 9, 11, 13]

reduce（）

标准库functools中的函数reduce（）可以将一个接收2个参数的函数以迭代累积的方式从左到右依次作用到一个序列或迭代器对象的所有元素上，并且允许指定一个初始值。

>>>from functools import reduce
>>>seq=list(range(1,10))
>>>reduce(lambda x,y:x+y,seq)
45

内置函数filter（）将一个单参数函数作用到一个序列上，返回该系列中使得该函数返回值为True的那些元素组成的filter对象，如果指定函数为None，则返回序列中等价于True的元素。

>>>seq=['foo','x41','\?!','***']
>>>def func(x):
    return x.isalnum()                                   #测试是否为字母或数字

>>>filter(func,seq)                                       #filter（函数，序列）
<filter object at 0x000001C4C9DCF730>   #返回filter对象

>>>list(filter(func,seq))                                #把filter对象转换为列表，但很少这样做
['foo', 'x41']
 

 range（）

是python开发中非常常用的一个内置函数，语法格式为range（[start,] end [,step]）。该函数返回具有惰性求值特点的range对象，其中包含左闭右开区间[start,end)内以step为步长的整数。参数start默认为，step默认为1。

>>>range(5)                 #start默认为0，step默认为1
range(0, 5)

>>>list(_)                      #_:上一次正确的输出结果
[0, 1, 2, 3, 4]

>>>list(range(1,10,2))  #指定起始值为1和10，步长为2
[1, 3, 5, 7, 9]

>>>list(range(9,0,-2)) #步长为负数时，start应比end大
[9, 7, 5, 3, 1]

zip（）函数

用来把多个可迭代对象中的元素压缩到一起，返回一个可迭代的zip对象，其中每个元素嗾使包含原来的多个可迭代对象对应位置上元素的元组，认同拉拉链一样。

>>>list(zip('abcd',[1,2,3]))               #压缩字符串和列表，以短的序列为结束
[('a', 1), ('b', 2), ('c', 3)]

>>>list(zip('123','abc',',.!'))               #压缩三个序列
[('1', 'a', ','), ('2', 'b', '.'), ('3', 'c', '!')]

>>>x=zip('abcd','1234')
>>>list(x)
[('a', '1'), ('b', '2'), ('c', '3'), ('d', '4')] 

对象的删除

在python中具有自动内存管理功能，python解释器会跟踪所有的值，一旦发现某个值不再有任何变量指向，将会自动删除该值。尽管如此，自动内存管理或者垃圾回收机制并不能保证及时释放内存。显示释放自己申请的资源是程序员的好习惯之一，也是程序员素养的体现之一。

在python中，可以使用del命令来显示删除对象并解释与值之间的指向关系。删除对象时，如果指向的值还有别的变量指向则不删除该值，如果删除对象后该值不再有其他的变量指向，则删除该值。

>>>x=[1,2,3,4,5,6]                                            #定义一个列表
>>>y=3
>>>z=y                                                            #z和y都指向整数3

>>>print(y)                                                       #查看y

3

>>>del y                                                           #删除y
print(y)                                                              #查看y，不存在
Traceback (most recent call last):
  File "<pyshell#5>", line 1, in <module>
    print(y)
NameError: name 'y' is not defined

>>>print(z)                                                         #查看z
3                                                                        #3在内存中没有被删掉，还有z指向它

>>>del z                                                             #删除z
>>>print(z)                                                         #查看z，不存在；

                                                               #3还是存在的，还有我们不知道的一些对象在引用它
Traceback (most recent call last):
  File "<pyshell#8>", line 1, in <module>
    print(z)
NameError: name 'z' is not defined

>>>del x[1]                                       #删除列表中下标为1的值
>>>print(x)
[1, 3, 4, 5, 6]

>>>del x                                           #删除整个列表
>>>print(x)
Traceback (most recent call last):
  File "<pyshell#12>", line 1, in <module>
    print(x)
NameError: name 'x' is not defined

del命令无法删除元组或者字符串中的元素，只可以删除整个元组或字符串，因为这两者属于不可变序列。

>>>x=(1,2,3)                                          #定义一个元组
>>>del x[1]
Traceback (most recent call last):
  File "<pyshell#14>", line 1, in <module>
    del x[1]
TypeError: 'tuple' object doesn't support item deletion       #元组对象不支持元素的删除

>>>del x                                                 #可以删除整个元组
>>>print(x)
Traceback (most recent call last):
  File "<pyshell#16>", line 1, in <module>
    print(x)
NameError: name 'x' is not defined

基本输入输出

用python进行程序设计，输入是通过input（）函数来实现的，input（）的一般格式为：

x = input('提示：')

该函数返回输入的对象。可以输入数字、字符串和其他任意类型对象。

在python 3.x中，不存在raw_input函数，只提供了input（）函数用来接用户的键盘输入。在python 3.x中，不论用户输入数据时使用什么界定符，input（）函数的返回结果都是字符串，需要将其转换为相应的类型再处理。例如下面的代码（python 3.10.7）

>>>x=input('Please input:')
Please input:3
>>>print(type(x))
<class 'str'>

>>>x=input('Please input:')
Please input:'1'
>>>print(type(x))
<class 'str'>

>>>x=input('Please input:')
Please input:[1,2]
>>>print(type(x))
<class 'str'>

>>>x=raw_input("Please input:")
Traceback (most recent call last):
  File "<pyshell#24>", line 1, in <module>
    x=raw_input("Please input:")
NameError: name 'raw_input' is not defined

重定向

>>>fp = open(r'D:\mytest.txt','a+')      #以追加的方式打开文件

>>>print('Hello,world!',file=fp)             #将Hello,world!写入上面打开的文件

>>>fp.close()                                        #关闭文件

输出内容不换行（print输入默认换行）

>>>for i in range(10,20):
    print(i,end=' ')

    
10 11 12 13 14 15 16 17 18 19 

模块导入与使用

python默认安装仅包括部分基本或核心模块，但用户可以安装大量的扩展模块，pip是管理模块的重要工具。

在python启动时，仅加载了很少的一部分模块，在需要时由程序员显式地加载（可能需要先安装）其他模块。

减小运行的压力，仅加载真正需要的模块和功能，且具有很强的可扩展性。

可以使用sysmodules.items（）显示所有预加载模块的相关信息。

import 模块名 [as 别名]

>>>import math                               #导入math模块
>>>math.sin(0.5)                             #使用math中的sin计算0.5的正弦值
0.479425538604203

>>>import random                          #导入random模块
>>>x=random.random()                 #获得[0,1)内的随机小数
>>>y=random.random()
>>>n=random.randint(1,100)         #获得[1,100]上的随机整数

可以使用dir函数查看任意模块中所有的对象列表，如果调用不带参数的dir（）函数，则返回当前所有列表名字。

可以使用help函数查看任意模块的或函数的使用帮助

from 模块名 import 对象名[as 别名]

#可以减少查询次数，提高执行速度

>>>from math import sin
>>>sin(3)                              #不用加前面的math.
0.1411200080598672

>>>from math import sin as f      #从math模块中调用sin函数，起别名为f
>>>f(3)
0.1411200080598672

from math import *

#谨慎使用，从一个模块中导入所有的成员

在3.x中，需要使用imp模块的reload函数

python首先在当前目录中查找需要导入的模块文件，如果没有找到则从sys模块的path变量所指定的目录中查找。可以使用sys模块的path变量（列表）查看python导入模块时搜索的路径，也可以向其中append（在列表中方加入自己的）自定义的目录以扩展搜索路径。

在导入模块时，会优先带入相应的pcy文件，如果相应的pcy文件与py文件时间不相符，则导入py文件并重新编译该模块。

导入模块时的文件搜索顺序

1. 当前文件
2. syspath变量指定的文件夹
3. 优先导入pyc文件

如果需要导入多个模块，一般建议按如下顺序进行导入

1. 标准库
2. 成熟的第三方库
3. 自己开发的库

---

1.5python代码规范

缩进

• 类定义、函数定义、选择结构、循环结构，行尾的冒号表示缩进的开始；
• python程序是依靠代码块的缩进来体现代码之间逻辑关系的，缩进结束就表示一盒代码块结束了；
• 同一个级别的代码块的缩进量必须相同；
• 一而言，以4个空格为基本缩进单位；

注释

一个好的、可读性强的程序一般包含30%以上的注释。常用的注释方式有两种：

• 以#开始，表示本行#之后的内容为注释
• 包含子啊一对三引号'''...''' 或"""..."""(三双引号)之前且不属于任何语句的内容将被解释器认为是注释

在IDLE开发环境中，可以通过下面的操作快速解释/解除大段内容：Format-->Comment Out Region/Uncomment Region

每个import只导入一个模块

标准库、扩展库、自定义库

换行

• 如果一个语句太长，可以在行尾加上\来换行分成多行，但是建议使用括号来包含多行内容。

必要的空格与空行

• 运算符两侧、逗号后面建议增加一个空格；
• 不同功能的代码块之间、不同的函数定义之间建议增加一个空行以增加可读性；

异常处理

适当使用异常处理结构进行容错，后面讲解

软件应具有较强的可测试性，测试与开发齐头并进。

1.6python文件名

py:Python源文件,由Python解释器负责解释执行。

pyw: Python源文件,常用于图形界面程序文件。

pyc: Python字节码文件,无法使用文本编辑器直接查看该类型文件内容,可用于隐藏Python源代码和提高运行速度。对于Python模块,第一次被导入时将被编译成字节码的形式,并在以后再次导入时优先使用“.pyc”文件,以提高模块的加载和运行速度。对于非模块文件,直接执行时并不生成“.pyc”文件,但可以使用py_compile模块的compile()函数进行编译以提高加载和运行速度。另外,Python还提供了compileall模块,其中包含compile_dir()、compile_file()和compile_path()等方法,用来支持批量Python源程序文件的编译。

pyo:优化的Python字节码文件,同样无法使用文本编辑器直接查看其内容。可以使用“python -0 -m py_compile file.py”或“python -00 -m py_compile file.py”进行优化编译。Python 3.5不再支持.pyo文件。

pyd:一般是由其他语言编写并编译的二进制文件,常用于实现某些软件工具的Python编程接口插件或Python动态链接库。

参考网址

Python基础1：版本、安装_哔哩哔哩_bilibili

Python基础2：扩展库管理与对象模型_哔哩哔哩_bilibili

Python基础3：变量、数字、字符串_哔哩哔哩_bilibili

Python基础4：运算符与表达式_哔哩哔哩_bilibili

Python基础5：内置函数1_哔哩哔哩_bilibili

Python基础6：内置函数2_哔哩哔哩_bilibili

Python基础7：基本输入输出、模块对象导入_哔哩哔哩_bilibili

Python基础8：Python代码编写规范_哔哩哔哩_bilibili