【学习笔记】Python基础入门知识笔记，万字攻略带你走进Python编程

​ Python笔记，由此开始吧
本文是笔者在学习Python过程做的笔记总结，将简要讲述Python的基础知识，内容清晰易理解，相信你也能轻松的学会Python的入门基础知识内容。同时也希望这篇文章对你起到帮助，相信你一定会有所学成的。现在让我们一起来看看吧！

---

Python编辑器与Python解释器

编辑器：用于编写Python代码的软件
解释器：用于执行编写完成的Python

标识符：变量

变量是内存中命名的存储位置，变量的值可以实时动态变化。

在Python中，通常同一缩进格式的区域为程序作用域，作用域内的变量叫做局部变量，变量在出作用域后会被释放。写在最顶格外面的即为全局变量。例如在函数体外的变量为全局变量，函数体内的变量为局部变量。
例子如下：

a  = 1  #  ===> 将 1 定义给 a
b  = 20  # ===> 将 20 定义给 b
c,d ='ladies','gentlemen' #  ===>分别定义
print(f'a是{a}')
print(f'b是{b}')
print(f'c是{c}')
print(f'd是{d}')
print(f'c,d一起输出{c,d}')

a是1
b是20
c是ladies
d是gentlemen
c,d一起输出('ladies', 'gentlemen')

变量名称定义后会占用一定的内存空间，如果使用完成后可以选择将其释放。方法是 del (变量名)
例如：

a =10
del (a)
print(a)
# 变量a已经被释放，再print会报错

---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-71-9656e0374dab> in <module>
      1 a =10
      2 del (a)
----> 3 print(a)
      4 


NameError: name 'a' is not defined

变量命名规则：

①不得使用作为数字开头；

③不得使用空格，可以用下划线连接变量名称；

④不得使用标识符号（#）在其中；

⑤不得使用中文作为变量名称；

⑥不得使用以下关键字作为开头

简记：2种情况不能做开头：数字、关键字；
3种情况不允许出现：空格、标识符（#）、中文

注释语句

Python中 #号右边的内容无需Python解释器理解，通常用于Python中注释语句时使用。
可以用于程序测试语句中，注释以后无需删除原句，用于下次使用。
多行注释使用三引号进行注释：""" 注释内容 “”"
例如：

print('准备运行一个注释语句')  #注释。。。

# print("注释语句")

#  多行注释可以使用三引号进行注释。

缩进

缩进语句通常用在特殊语句的特殊写法，可以确定语句的执行区域。
如下例：

a =10
if a ==10:
    print('执行if !')
    print('if语句执行完成！')
    if a=>10:
        print()
print('Process finished with exit code 0.')

  File "<ipython-input-72-64836e029d12>", line 5
    if a=>10:
        ^
SyntaxError: invalid syntax

输出语句print()

输出语句print()是Python中最常见的语句，该语法会将内容完整的输出到电脑控制台上或文件当中。
本处将会简要说明print()语句的一些用法

a =10
print(a)  # 输出变量
print(3)  # 直接输出数字
print('Hello')  # 添加引号可以直接输出文本  
print(1+2)  #  直接输出算数结果
print()  # 直接输入print()会换行

多行输出

通常的，print()语句只能输出单行，如果要输出多行可以用到三引号或转义字符（本处讲三引号） 三引号：3 个单引号或3个双引号

print会从你引号的地方一直输出到最后一个引号位置，可以换行。

print('''Caixy
            L
r''')

选择性输出

如果一句完整的话不需要完整输出，那么可以用到切片操作，本处将会简单介绍切片操作，后续会详解切片操作

# 例

word = 'ABCDE'
# 如果只需要输出ABC，而不要DE  切法 ：[ ：终点]
print(word[:3])
# 如果不需要输出ABC   切法： [起点：]
print(word[3:])

常见的基础数据类型

整数值类型- int -98；
浮点数类型- float -3.1415926；
布尔值类型- bool -True，False；
字符串类型- str -‘Hello Caixy’,‘你好’。

int_ =98
float_ =3.1415
bool1 =True
bool2 =False
str_ ='Hello everyone!'

print(f'int_是{int_}，数据类型是 {type(int_)}\n')  #  通常的，直接写出的整数是int整数类型。

print(f'float_是{float_}，数据类型是 {type(float_)}\n')  #  通常的，直接写出的小数是fLoat浮点数类型。

print(f'bool1是{bool1}，数据类型是 {type(bool1)}\n')  #  通常的，直接写出的True是布尔值类型。

print(f'bool2是{bool2}，数据类型是 {type(bool2)}\n')  #  通常的，直接写出的False是布尔值类型。

print(f'str_是{str_}，数据类型是 {type(str_)}')  #  通常的，直接写出带引号的文本是字符串类型。

数据类型转换

在平时编写代码的过程中，会常常出现不同的数据类型， 而不同的数据类型是无法进行连接使用或比较的。
所以这个时候就需要用到了 “数据类型转换”。

Python中，可以使用type(变量名)查看该变量的数据类型。

# Python数据类型转换
int_ =98
float_ =3.1415
bool1 =True
bool2 =False
str_ ='Hello everyone!'

print(f'int_是{int_}，数据类型是 {type(int_)}\n')  

print(f'float_是{float_}，数据类型是 {type(float_)}\n')  

print(f'bool1是{bool1}，数据类型是 {type(bool1)}\n') 

print(f'bool2是{bool2}，数据类型是 {type(bool2)}\n')  

print(f'str_是{str_}，数据类型是 {type(str_)}\n') 

print('===================================')
print()

 # 数据类型转换：只需要将想转化的数据类型写出来，并在括号内写入变量名称即可
new_int_float = float(int_) 
new_float_int = int(float_)
new_bool1_int = int(bool1)
new_bool2_int = int(bool2)
new_int_str = str(int_)


print(f'int_是{int_}，新的int_到float的值是{new_int_float}，数据类型是{type(new_int_float)}\n')
print(f'float_是{float_}，新的float_到int的值是{new_float_int}，数据类型是{type(new_float_int)}\n')
print(f'bool1是{bool1}，新的bool1到int的值是{new_bool1_int}，数据类型是{type(new_bool1_int)}\n')
print(f'bool2是{bool2}，新的bool2到int的值是{new_bool2_int}，数据类型是{type(new_bool2_int)}\n')
print(f'int_是{int_}，新的int_到str的值是{new_int_str}，数据类型是{type(new_int_str)}\n')

连接输出

如果要打印输出多个同类型变量值，可以使用“+”将其连接，或是使用逗号‘,’分割开。
区别：“+”无空格，逗号“，”有空格。
试试看将文本连起来一起输出

# 文本添加会直接连在一起  例：
a ='A'
b ='B'
print(a+b)

a = 'Caixy'
b = '十'
print('我叫'+a+'，今年',b,'岁了，请多多光照！')

a ='Caixy'
b =10
print('我叫'+a+'，今年'+b+'岁了，请多多光照！')
#  这段会运行报错

要同时输出打印时，需要相同的数据类型才能同时输出，否则会报错。
下面为转化后的正常写法。

a ='Caixy'
b =10
print('我叫'+a+'，今年'+str(b)+'岁了，请多多光照！')

格式化字符串

使用格式化字符串可以无需通过转化类型就可以直接输出，同时格式化字符串还可以输出表达式。

第一种：%占位符：用 %号占位，其中%s占字符串，%d占整数型，%f占浮点数，%b占布尔值；依次填入且不能调整位置

#  %例：
n ='Caixy'
a =10

print('我叫%s。%s'%(n,a))

第二种：.format()占位：用.format语句进行变量存储，用{}占位，依次填入，但可以调整位置

# .format例：
n ='Caixy'
a =10

print('我叫{1}，今年{0}岁了。'.format(n,a))

第三种：f-string格式占位：在引号左侧写一个f，文本内容添加{}即可对应提取变量依次填入。

# f-string例：
n ='Caixy'
a =10

print(f'我叫{n}，今年{a}岁了。')

格式化高级使用：

在平时编程当中，为了编写规范，通常会用到隔一段距离输出或是精确小数点。这时候可以用到格式化的高级使用进行代码优化。

空格使用：空出内容对应长度 n。其中包括字符串长度 d，前面空出n-d个长。

#  % 类型
n ='Caixy'
a =10

print('%10s'%n)
print('%10d'%a)

#  小结：%长度 类型，表示空格 ，严格遵守类型符号 s 文本 d整数 f小数 b布尔

#  .format 类型
n ='Caixy'
a =10
print('{0:10}'.format(a))  #  ===> 数字类型可以直接写 起点 ：终点长度
print('{:>10}'.format(n))  #  ===> 字符类型需加上方向符号 <>
print('{:>10}{:<10}'.format(n,a))  #  > 是向右对齐，即向右边空出位置，< 同理为向左

#  小结：加上 冒号（：），表示空格；
#  其中数字类型可以直接写 起点 ：终点长度 ，起点默认为0 ；   文本需加上方向符号
#  方向符号方法  数字类型可以和文本共用

f-string类型没有空格功能

小数点使用：

# % 类型
pai =3.1415926
print('%f'%pai)  #  ===>%f表示浮点数，自动精确到最后一位小数，四舍五入
print('%.3f'%pai)  #  ===>加上  .3f 即精确三位小数

#  小结：%f 默认精确到最后一位数，加上 .位数f   可以精确到对应小数点位置，整数默认补0

# .format类型
pai =3.1415926
print('{:.3f}'.format(pai))  #  ===> 精确小数点3位
print('{:.3}'.format(pai))  #  ===>有效长度 3位
print('{0:.5f}'.format(pai))  # ===> 有效长度五位，精确5位小数
print('======')
print(pai)

#  小结：默认起点为0，: . 字符有效长度。加上f > :.位数f  可以精确到对应小数点位置，整数默认补0

f-string类型没有精确小数功能

空格和精确小数同时使用

# % 类型
pai = 3.1415926
print('%10.3f'%pai)  #===>  %10.3f，一共总宽度为10，小数点精确后3位

#  小结 ：%长度 .精确位数

#  .format 类型
print('{0:10.3f}'.format(pai))  # ===> 0:10.3f ，一共总宽度为10，小数点精确后3位

# 小结： {起点：终点 .精确位数}

f-string类型：“我无了！”

小结：%号 语句规范无法调整位置，.format语句较规范且功能强大，f-string方式简洁且主要以输出内容为主

计算机进制

本处只会简要介绍计算机常见进制以及表示。

十进制

十进制：Python默认进制。缩写：DEC。如：整数：0、-1、9、123；

二进制

二进制：以0b开头，缩写：BIN。如：0b101、0b100；

八进制

八进制：以0o开头，缩写：OCT。如：0o35、0o11;

十六进制

十六进制：以0x开头，缩写：HEX。如：0x10、0xfa、0xabcdef;

进制转换

Python中默认机制为 十进制。进制也算前面的数据类型一种。

在平时编写代码或其他数据加密过程当中，通常需要进制转换进行数据加密解密等，这时就需要了进制转换。

既然也算数据类型一种，那么它转化方法跟数据类型转化同理。

# 例

num = 123

bin_ =bin(num)
oct_ =oct(num)
hex_ =hex(num)

print(f'''初始值（十进制）：{num};
转化后二进制是：{bin_};
转化后八进制是：{oct_};
转化后十六进制是：{hex_}.''')

转义字符

通常需要文本空格或换行时，可以直接使用转义字符进行便捷操作

换行：\n（newline）：将一段长文本另起一行继续表示。

print('new\nline')

回车：\r（return）：将同一段字符串内的转义符前面的内容清除取代

print('re\rturn')

水平制表符：\t（tab）：自动填充4个单位的空格。

print('ta\tb')
print('hello')

ta	b
hello

退格：\b（backspace）：在一个字符串内退去一个字符。

print('back\bspace')

backspace

原字符：在引号前加r或R：让本字符串内的转义字符不起作用。

print(r'un\nknow')

un\nknow

input()输入语句

在编写过程中，通常会遇到需要与用户交互进行输入内容，这时候就可以使用input()语句进行输入内容

使用时只需要写出input()即可，如果需要接收input()传来的内容，可以定义一个变量将input内容赋予给该变量

# 例
use_input = input()  # 括号内可以添加文本用来提示输入
print(f'use_input是{use_input}')

7 8
use_input是7 8

如果可以接收内容以后，我们是否可以通过内容输入制作一个简单的计算器呢？

num1 =int(input('请输入一个数字：'))
num2 =int(input('请输入一个数字：'))
print(num1+num2)
print(f'num1类型是：{type(num1)}')

请输入一个数字：9
请输入一个数字：6
15
num1类型是：<class 'int'>

input()入口接收函数默认 字符串（str）类型。可以根据实际使用时更改数据类型

input() 语句高级使用：.split()

通常在接收用户所需要输入的内容时，经常会用到分割字符传达过来的字符

例如，题目要求：num即将接收六个内容，用空格分开：1 2 3 4 5 6 ；

那么可以用到字符的分割写法：.split()

.split()写法：当需要接收多个时，可以用在input()函数外表示切割

# 形如：
num = input().split()  #  当.split()内不填写任何内容时，默认以 空格作为单位
print(num)

# 写多少个就接收多少个，遇到需要分割的内容依次作为一个单位分割

7 8
['7', '8']

#  可以声明多个变量，会依次填入对应变量
a,b = input().split()

print(a)
print(b)

# 这里就不是输多少接多少，只会接收变量数个内容，超过或缺少 都会报错。

# 批量修改.split()内容数据类型
num = list(map(int, input().split()))
#这个是随便接受任何数据长度的内容，以空格为结尾，并默认转成int类型，转换失败会报错。结果会存储到列表当中(列表详解在后文)

9 6
9
6

原生字符串也使用.split()写法

word = 'Hello everyone! I am Caixy!'.split()
print(word)

['Hello', 'everyone!', 'I', 'am', 'Caixy!']

.split()写法默认会从头切到尾，如果要限制切割数量，可以用下面的写法

word = 'I am Caixy ,  I am 10 years old ,Thank you！'.split()
print(word)

['I', 'am', 'Caixy', ',', 'I', 'am', '10', 'years', 'old', ',Thank', 'you！']

*eval()函数

eval是Python的一个内置函数，功能十分强大，这个函数的作用是：可以 将字符串当成有效的表达式 来求值 并 返回计算结果。

a = input()
a = eval(a)
print(type(a))

9
<class 'int'>

eval() 直接实现字符串转化至整数型，并且计算

s = '1+2+3*4-5'
print(eval(s))

10

同样可以结合input()进行使用

num = input()
print(eval(num))

num1 = eval(input())
print(num1)

8+7
15
7+8
15

eval() 直接实现带变量计算

a  = 1
print(eval('a+2'))

3

eval()函数的缺点：eval函数还有一项功能，就是可以直接执行命令。这也同时也是它的一项缺点

eval('print("Hello Everyone!")')

Hello Everyone!

在后续如果需要做大项目的编程时，尽量避免使用eval作为与用户的交互处，避免出现恶意输入。

运算符讲解

运算符优先级：算术优先级 > 位运算符(本课未涉及) > 比较运算符 > 布尔运算符 > 赋值运算符 （可以通过括号()改变优先级）

算术运算符

＋ - * / // % **

以下假设变量： a=10，b=20：

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 30
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -10
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 200
/	除 - x除以y	b / a 输出结果 2
%	取模 - 返回除法的余数	b % a 输出结果 0
**	幂 - 返回x的y次幂	a**b 为10的20次方， 输出结果 100000000000000000000
//	取整除 - 返回商的整数部分（向下取整）	>>> 9//2 4 >>> -9//2 -5

位运算符

<< >> （&、|、^、~ 这四个了解即可，主要了解外面两个）

下表中变量 a 为 60，b 为 13，二进制格式如下：

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

运算符	描述	实例
<<	左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111
&	按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
|	按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。	(a | b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。

比较运算符

< <= > >= !=

以下假设变量a为10，变量b为20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.
<>	不等于 - 比较两个对象是否不相等。python3 已废弃。	(a <> b) 返回 true。这个运算符类似 != 。
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

布尔(逻辑)运算符

and or not in (not in)

Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是非 0，它返回 x 的计算值，否则它返回 y 的计算值。	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

赋值运算符

== += -= *= /= //= %=

以下假设变量a为10，变量b为20：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c *= a 等效于 c = c * a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c **= a 等效于 c = c ** a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

判断语句:if

判断条件语句是否成立，成立则执行区域内代码

a = 5
if a ==5:
    print('a=5')
print('Done!')

a=5
Done!

判断语句的嵌套：if-elif-else

判断语句支持多项成立条件，执行不同情况语句，且允许嵌套

a = 10 
if a >5:
    if a>8:
        if a>= 10:
            print(a)

10

range()生成数 语句

range(起点：终点（但不包含终点）：步长（默认为1）)

for 循环语句

for循环语句是用于将一个可迭代对象逐个进行循环输出的方法函数，主要写法就是

for var in iter :

iter为一个可迭代对象，可迭代对象主要为range函数，字符串、数组等等。在Python里面来说，几乎所有的内容都属于可迭代对象；

var为一个赋值变量，正如上面所说，for循环是将一个可迭代对象逐个赋予给一个新变量以此达到赋值循环的目的。

在Python中，for循环的思想就是：将一个可遍历（迭代）的项目，对其内容每一个元素依次作为循环变量并使用。同时，Python还支持循环结束后的预处理，当你需要在程序正常运行结束时执行某一语句时，你可以使用else语句(详见for循环的特殊写法)。

for循环语法结构：
for 循环变量 in 循环对象: # 循环主体
	循环执行语句......
else: # 当循环结束后执行某一语段，那么你需要写上else语句
	else语段 # else语段里，不允许使用循环变量。

那么，for循环该如何使用呢？

# 实例1: 循环字符串
# 循环字符串，此时Python会将字符串内所有内容逐个赋予给循环变量word，并允许你在for的缩进作用域内使用循环变量word。
for word in "Python":
	print("当前字母: {}".format(word))

"""
实例1 输出结果：

当前字母: P
当前字母: y
当前字母: t
当前字母: h
当前字母: o
当前字母: n
"""

# 实例2：循环列表序列
# 在Python中，你可以在特定的方法中循环使用你的临时存储数据方法，包括你的列表。

color_lst = ["red", "black", "blue"]
for color in color_lst:
	print("当前颜色: {}".format(color))

"""
实例2 输出结果：

当前颜色: red
当前颜色: black
当前颜色: blue
"""

# 实例3：计数循环
# Python提供了range()函数结合for循环能将你的代码段运行多次。
# range()函数同时还是一个生成数函数，它的函数参数为range(start, end, step=1)。
# 其中，参数含义分别为：start=开始计数的位置，end=不包括自身的结束位置，step=每次的步长。

for i in range(3):
	print("当前循环数：{}".format(i))

"""
实例3 输出结果：

当前循环数：0
当前循环数：1
当前循环数：2
"""

for循环的特殊写法

在for循环当中，有一个特殊的分支写法：即for…else:写法

该写法的主要用于：当程序正常循环结束以后，执行else语句的内容；小Tips：如果程序异常退出或使用了break语句，则不会执行else

例如：

# 正常循环结束时，执行else语句
for i in range(3):
    print(i)
else:
    print("Done!")
# >>> Output: 0 1 2 Done!
# 非正常结束循环：程序异常退出、使用了break语句，不会执行else
for i in range(3):
    if i:
        break
else:
    print("Done!")
# >>> 没有输出

while 循环语句

while循环形如其他编程语言，只要条件成立，则while循环继续；

在Python的while循环当中，循环规则为先判断条件后循环；循环执行语句可以是单个语句或语句块。判断条件可以是任何表达式，任何非零、或非空（null）的值均为 True。当判断条件假 False 时，循环结束。

while循环语法结构：
while 判断条件(condition)：
    循环执行语句......
else: # 当循环结束后执行某一语段，那么你需要写上else语句
    else语段

现在，我们将通过3个实例，为你讲解while循环的使用方法

# 实例1：计数循环
count = 0
while (count < 5):
   print("当前循环数:".format(count))
   count = count + 1
   
"""
实例1 执行结果：

当前循环数: 0
当前循环数: 1
当前循环数: 2
当前循环数: 3
当前循环数: 4
当前循环数: 5
"""

# 实例2：循环使用 else 语句
# 在 python 中，while … else 在循环条件为 false 时执行 else 语句块：
while (count < 5):
    print("The count is:".format(count))
    count = count + 1
else:
    print("循环结束！！！")
    
"""
实例2 执行结果：

当前循环数: 0
当前循环数: 1
当前循环数: 2
当前循环数: 3
当前循环数: 4
当前循环数: 5
循环结束！！！
"""

# 实例3：无限循环
# 结合while循环的使用细则，当条件成立 True时，那么循环就会一直进行下去。利用这个机制，我们可以写出无限循环格式。
while True:
    print("RUNNING!")
    
"""
实例3 执行结果：

RUNNING!
RUNNING!
RUNNING!
RUNNING!
RUNNING!
...... (此时无干预的情况下程序将一直输出下去)
"""
# 无限循环下，你可以使用CTRL+C 中断循环

切片操作

切片操作可以用在我们Python代码中许多地方，其主要功能就是可以提取指定位置或区域的内容

切片操作很多，需要多练巩固熟记

知识点

在Python中，表示位置的区域大多数都是会从0开始计数，所以长度为n的单位，在Python中的长度就是n-1。

word = "1254125"

切片常用表示和其具体含义：变量名称[a: b :c]，其中并不是每一个内容都是必须填入的。

c = 间隔位置/方向（c默认=1，c为正数时，从左往右；c为负数时，从右往左）c的值非常重要！！因为它关系着a b的方向

a = 开始位置（包括该点，默认为开头，c为正数时从开头位置开始，c为负数从结尾开始）；

b = 结束位置（不包括该点，，c为正数时到结尾位置结束，c为负数时到开头位置结束）；

a和b确定的起点和终点，确立起切片的执行区域的方向

c 确定的间隔/方向，确立起切片的开始方向

a+b的方向与c的方向相同，才可以切出内容。

如果a+b的方向和c的方向不同，切片会切不出内容。

如果ab不填，就默认为c的方向作为起点终点

查看切片的步骤

① 先通过起点和终点，判断其执行区域的方向

② 再看c的正负，判断其开始方向

现在开始进入切片吧

切片内容翻转

word = "Python"
result = word[::-1]
print(result)

nohtyP

切片1：[开始位置：]

# 【开始（不包括）:】
word = "Python"
result = word[1:]
print(result)

ython

切片2：[ :结束位置]

#  【开始位置（不包括）：结束位置（不包括）】
word = "Python"
result = word[1:4]
print(result)

yth

切片3：[开始：结束：间隔]

#  间隔n-1个位置进行取出
word = "Python"
result = word[1:6:2]
print(result)

yhn

word = "Python"
result = word[6:1:-1]  #  开始和结束的方向要与c的方向相同
print(result)

noht

列表：list()

列表(list)是一种有序的容器，放入list中的元素将会按照0~n的顺序排列。

# 形如：带着中括号的 [ ]可以看作是列表
L = ['Alice', 66, 'Bob', True, 'False', 100]

列表内的数据以每一个“，”逗号作为间隔，一个间隔一个数据。采用0~n-1的方式排序。

列表内的元素可以存放任意数据类型的内容，且放进的内容数据类型不会改变。也是Python当中常用的数据存储方式。

列表定义方法：

符号定义法：

L = [ ]
print(type(L))
data_list = [1,2,6,8,"Hello","Jupyter0","teach"]
print(type(data_list))
print(data_list)

# 直接定义list的方法非常简单，使用中括号[ ]把需要放在容器里面的元素括起来，就定义了一个列表。

<class 'list'>
<class 'list'>
[1, 2, 6, 8, 'Hello', 'Jupyter0', 'teach']

名称定义法：

data = "123998"
data_list = list(data)
print(data_list)

#  定义list的方法是声明一个变量，写出其函数名称即可 ：  变量名称 = list()
#  这种方法会逐个将内容拆分，逐个放进列表当中，类似于for循环

['1', '2', '3', '9', '9', '8']

列表常见操作

查看列表长度

通常在一段长列表当中，我们一个个数列表的长度太难，所以我们可以用len()方法获取列表长度。

获取列表长度：len(列表名称)，这里就是直接从1~n写出它的长度，不会从0开始算。

L = ['Alice', 66, 'Bob', True, 'False', 100]
ER  = [[1,2,3],
      [2,3,4]]
print(len(L))
print(ER[0][1])

6
2

获取列表内容

获取列表内容，可以通过列表位置获取列表内容。

方法：列表名称【提取的位置】0~n

L = ['Alice', 66, 'Bob', True, 'False', 100]
print(L[3])

True

如何逐个遍历列表内容呢？

L = ['Alice', 66, 'Bob', True, 'False', 100]
for i in range(len(L)):
    print(L[i])

Alice
66
Bob
True
False
100

增加内容进入列表当中

当已定义好一个列表，那么我们需要不断添加内容数据。

直接添加法，将内容添加到列表最末尾：列表名称.append(填入的内容)

L = ['Alice', 66, 'Bob', True, 'False', 100]
# 添加在最末尾：列表名称.append(填入的内容)
L.append("None")
print(L)

['Alice', 66, 'Bob', True, 'False', 100, 'None']

位置添加法：将内容添加到列表的指定位置：列表名称.insert(插入位置，“填入的内容”)

L = ['Alice', 66, 'Bob', True, 'False', 100]
L.insert(5,"None")
print(L)

#  小结：填入的位置序号，就是它即将放置的位置。

['Alice', 66, 'Bob', True, 'False', 'None', 100]

删除列表内容

删除列表中的内容，可以用.pop方法删除：列表名称.pop()。其中pop()括号内容可不填内容，默认删除最后一个元素，填入数字删除指定位置

L = ['Alice', 66, 'Bob', True, 'False', 100]
#  列表名称.pop()
L.pop(1)
print(L)

['Alice', 'Bob', True, 'False', 100]

清空列表

L = ['Alice', 66, 'Bob', True, 'False', 100]
L.clear()
print(L)

[]

替换列表内容

讲了取增删的方法，那么如何修改列表里面的内容呢？

方法：列表名称【替换的位置】 = 替换名称

注意：这种方法不能作为添加内容的方法，因为替换位置超出列表长度会报错

L = ['Alice', 66, 'Bob', True, 'False', 100]
L[0] = "Cia"
print(L)

['Cia', 66, 'Bob', True, 'False', 100]

统计内容出现次数和位置

列表中，可以使用.count()方法统计字符出现同类型的个数

列表中，可以使用.index()方法输出该字符 第一次 出现在列表的下表位置（0~n）

L = ['Alice', 66, 'Bob', True, 'False', 100, 100, "100"]
print(L.count(100))
print(L.index(100))

2
5

列表：小结

到此为止，列表的基础常见操作讲完了，内容覆盖了如何定义列表，如何取、增、删、改等操作

字典：dict()

Python的dict就是专门保存映射的容器，例如可以使用dict可以方便的保存“名字”->“成绩”的映射。只要取出名字，就能知道其对应成绩

解决上面的问题中，我们可以使用名字作为key，成绩作为value。

在dict中，每一项包含一个key和一个value，key和value是一一对应的

定义字典

符号定义法

在定义里，我们使用花括号{}表示这是一个dict

然后key和value之间使用冒号:分割，并且每一组"key:value"的最后，以逗号","表示这一组的结束

#  形如

d = {
        'Alice': 45,
        'Bob': 60,
        'Candy': 75,
        'David': 86,
        'Ellena': 49,
        'Gaven': 86,
    }
print(type(d))
print(d)

<class 'dict'>
{'Alice': 45, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 49, 'Gaven': 86}

直接定义法

同列表方法

d = dict()
print(d)

{}

字典常见操作

查看长度

与上同理，会输出n组数据。

d = {
        'Alice': 45,
        'Bob': 60,
        'Candy': 75,
        'David': 86,
        'Ellena': 49,
        'Gaven': 86,
    }
print(len(d))

6

获取字典内容

获取字典里的所有key

获取字典里的所有key可以使用 字典名称.keys()获取，括号内不可以填入内容，会默认输出从上至下所有的key

d = {
        'Alice': 45,
        'Bob': 60,
        'Candy': 75,
        'David': 86,
        'Ellena': 49,
        'Gaven': 86,
    }
print(d.keys())

dict_keys(['Alice', 'Bob', 'Candy', 'David', 'Ellena', 'Gaven'])

获取字典里的value

dict中，可以提供通过key找到对应value的功能，例如通过d[key]的形式，就可以得到对应的value。

d = {
    'Alice': 65,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 89,
    'Gaven': 86
}
print(d['Bob']) 
print(d['Alice']) 

60
65

# 获取所有的values()
d = {
    'Alice': 65,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 89,
    'Gaven': 86
}
print(d.values())

dict_values([65, 60, 75, 86, 89, 86])

小Tips

这里也可以结合for循环使用items()方法遍历字典，分别提取到出所有的key和value

d = {
    'Alice': [65,75],
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 89,
    'Gaven': 86
}

print(d.items())
for key,value in d.items():
    print("{} ==>{}".format(key,value))

dict_items([('Alice', [65, 75]), ('Bob', 60), ('Candy', 75), ('David', 86), ('Ellena', 89), ('Gaven', 86)])
Alice ==>[65, 75]
Bob ==>60
Candy ==>75
David ==>86
Ellena ==>89
Gaven ==>86

添加/更改 字典内的数据

字典内添加/更改的方法是一样的。

添加/更改的方法：字典名称【填入/更改的key】 = 【填入/更改的value】

要点：

当key不存在时，往dict中添加对应的key: value元素。

当key存在时，会更新dict，用新的value替换原来的value。

d = {
    'Alice': 65,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 89,
    'Gaven': 86
}

d["Ellena"] = [89,90]
print(d)

{'Alice': 65, 'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': [89, 90], 'Gaven': 86}

删除字典里的内容

字典中，可以使用.pop()方法删除对应key的内容。

#  方法：字典名称.pop("Key的名称")
d = {
    'Alice': 65,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 89,
    'Gaven': 86
}
d.pop("Alice")  # 会返回删除掉的key的value值
print(d)

{'Bob': 60, 'Candy': 75, 'David': 86, 'Ellena': 89, 'Gaven': 86}

#  清空字典
d = {
    'Alice': 65,
    'Bob': 60,
    'Candy': 75,
    'David': 86,
    'Ellena': 89,
    'Gaven': 86
}
d.clear()
print(d)

{}

元组：tuple()

元组(tuple)和list一样，也是一个有序容器，定义元组的方式是使用小括号( )将元组内的元素括起来。

特点：tuple容器与List容器的差别就在于，tuple容器中的数据不可更改，不可添加，

所以在实际编程中，tuple经常用于存放固定不变的数据。

定义元组的方法

符号定义法

可以使用小括号()直接声明一个元组。

直接定义法

T = (0,1,2,3,4,5,6,7,8,9)
print(type(T))
print(T)

<class 'tuple'>
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

变量定义法

T = 1, 2, 3, 4, 5, 6
print(T)

访问元组数据出现次数以及下标识

同列表的方法一样，用count()统计同类型数据出现个数，用.index()方法统计数据第一次出现的个数

修改/替换/删除元组内的数据

#  能不能做呢？
T = (0,1,2,3,4,5,6,7,8,9)
# 因为元组内的数据不允许被操作，所以元组不支持修改/替换/删除的操作 

集合：set()

set集合内的数据没有顺序(无法提取)，且不允许重复，如果存在重复的数据则会覆盖，打印输出时只会输出一个数据。

set集合通常使用一个小括号表示([])，内部数据常用列表保存

定义集合的方法

直接定义法

因为集合和元组同样使用小括号()进行表示，所以在具体使用过程当中，小括号()会默认定义为元组，set只有如下方法

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
s = set(names)
print(s)
se = set()
print(se)

{'Ellena', 'Bob', 'Alice', 'David', 'Candy'}
set()

集合常用操作

集合当中，数据填入以后集合会默认进行内容排序，数字从到大小

s = set([1, 4, 3, 2, 5])
print(s)

{1, 2, 3, 4, 5}

读取集合内容

因为集合是没有顺序的，所以无法直接读取集合中指定位置的内容。但是可以判断元素是否在集合当中

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name_set = set(names)
print('Alice' in name_set)

True

添加set内的数据

通过定义变量，并配上“.add”可以直接添加单一的数据进入。

在集合set中，如果内容已存在，则不会添加

方法：集合名称.add(添加的内容)

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
name_set = set(names)
name_set.add('Bob')
print(name_set)

{'Ellena', 'Bob', 'Alice', 'David', 'Candy'}

批量添加内容

批量添加内容，可以用“.update”方法添加多个内容

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
new_names = ['Hally', 'Isen', 'Jenny', 'Karl']
name_set = set(names)
name_set.update(new_names)
print(name_set)

{'Karl', 'Ellena', 'Hally', 'Jenny', 'Bob', 'Alice', 'David', 'Isen', 'Candy'}

删除set集合内的数据

set中提供了“remove()”的方式删除数据。

但如果数据不在set中，系统则会报错。

name_set = set(['Jenny', 'Ellena', 'Alice', 'Candy'])
name_set.remove('enny')
print(name_set)

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-126-65cf2bc21630> in <module>
      1 name_set = set(['Jenny', 'Ellena', 'Alice', 'Candy'])
----> 2 name_set.remove('enny')
      3 print(name_set)


KeyError: 'enny'

如果不知道内容是否在set当中，避免报错，可以使用if语句进行判断内容是否在set当中进行下一步执行

set中remove()方法不存在会报错，但也同时提供了“discard()”方法不存在时不保存

name_set = set(['Jenny', 'Ellena', 'Alice', 'Candy'])
name_set.discard('Jnny')
print(name_set)

清空set内的内容，同样可以使用clear()方法清空

name_set = set(['Jenny', 'Ellena', 'Alice', 'Candy'])
name_set.clear()
print(name_set)

函数

什么是函数？

函数是执行特定功能的一段代码，函数可以将一段功能代码封装起来成为一个新的定义，在需要使用到函数功能时调用即可使用函数内的功能。

举例:常用的print()输出函数，查看类型的type()函数，进制转化的的bin()、oct()函数，查看内存位置的id()函数等都是函数，这些函数也叫做内置函数。

用函数做什么？

通常我们在编写代码过程当中，代码会从上至下执行到最后一行。

如果我们想要一个功能重复使用，或让其在自己预想的特定时候执行、集成使用特定功能，这个时候我们就可以用到函数的功能。

同时，统一封装功能编写函数便于我们对程序的调试维护、提高我们代码的可读性

在编写软件代码过程当中，最常用、最简单的编程方式就是函数式编程，程序由函数构成。

使用特定功能时均声明好功能函数，这样编程就可以如同搭积木一样的方法了。

函数的声明

通常的，编写函数使用定义法：def

"""  函数定义方法：其中中括号处可填可不填
def 任意的函数名称 （a,b）:   
    函数功能体
    [return xxx]  函数运行到函数体最后一行，或是return处结束运行，return语句的功能主要是将函数运行结果反馈至调用处。
变量 = 函数名称（a,b）
print()
"""

无需传入参数的函数

无需的传入的函数，就是在函数定义与使用的过程当中，不需要往函数内传入内容的函数叫做无参函数。

def example():
    print("Hello, This is a example function!!")
    return
example()

return语句功能主要是将函数运行结果反馈至调用处。同时函数运行到这里就会停止。return可以返回数字、文字或是表达式。

#  传回表达式
def calc():
    a = 10
    b = 20
    return a+b
function = calc()
print(function)

需要传入参数的函数

函数通常在无参数传入时，会固定执行函数体内的所有代码。

如果我们需要函数在特定的时候接收来自外部的内容来执行不一样的结果时，我们可以使用需要传参的函数，保持函数的动态性。

未定义参数的函数

#  例如：
def calc(a,b):  # a b统称形式参数 == 形参
    return a+b
function = calc(10,20)   # 传入参数位置对应着函数需要的参数位置，10传给a，20传给b。10和20统称为实际参数 == 实参
print(function)

函数中，需要n个参数就必须要传入n个参数，传多或传少均会报错

已定义参数的函数

# 例如
def calc(a,b=20,c):  # 默认定义好一个参数的值，则可以无需传入指定数量的参数，但必须放置在最右边
    return a+b
function = calc(10,30)
print(function)

这种已定义好的参数，只能放在函数参数框中最右边，其余地方均会报错。

如果在函数定义中已声明好参数以后，再去多传入指定位置的参数，会将传入的值定义给已存在的参数值

可变长度的参数函数

元组存储的可变参数函数

当我们在不确定函数传入的数量，或需要传入较多个内容时，可以使用可变长度的参数函数

# 例如：
def example(*num):
    return num

function = example(1,2,3,4,5,6,7)
print(function)

字典存储的可变参数函数

可变长度的参数不仅仅是可以存在元组当中，还可以存入到字典；

字典存储的可变长度函数，需要特别表明key和value的值，对应着 key = value;

# 例如：
def example(**num):
    return num

function = example(a=1,b=2,c=3,d=4)
print(function)

lambda表达式

lambda表达式是一行的函数。它们在其他语言中也被称为匿名函数。

如果你不想在程序中对一个函数使用两次，你可以想到用lambda表达式匿名函数，这样可以使得你的代码变得更加简洁。

lambda 表达式声明方法：

lambda用于简单的数据处理

表达式名称 = lambda 【即将填入的变量名称】：需要使用变量执行的命令。

可以用lambda表达式执行简单的内容处理

# 例如：
# f = lambda x,y : x+y

# # 调用方法：同函数调用
# print(f(10,20))

# 调用方法：直接调用

#  (lambda 【即将填入的变量名称】：需要使用变量执行的命令)(传入的内容)
print((lambda x,y : x+y)(10,20))

lambda可用于调用多个函数

当我们写好众多函数时，如果需要逐个调用函数相当于要多写许多内容。那么我们可以使用lambda表达式同时调用多个内容

# 例如


def t():
    print("Hello", end="")

def y():
    print(" World", end="")

def p():
    print(" Python",end="")
    
#  (lambda ：【需要调用的函数名称】）())
(lambda : [t(), y(),p()])()

程序运行略过：pass语句

通常我们在写程序时，初期为了程序后续制作经常会运行调试，但不是每次都能把每一段过程都写完。所以我们可以用上pass语句，让程序跳过该步骤。

使用pass语句可以让程序直接跳过该步骤而无需理解,并且不会报错。

# 例如：
a = 10
if a < 5:
    print("a<5")
else:
    pass

for i in range(10):
    pass

def example():
    pass

example()

异常处理 try…except…else…finally

通常我们在写程序时，难免会有部分代码导致程序崩溃。那么接下来的写法将讲述如何处理崩溃信息，并且避免程序崩溃。

try…except语句

处理try…except语句时，解释器会先运行try语句中的一句。如果try语句中的程序报错，那么程序就会运行expect语句

try:  
    for i in xx:
        pass
except:
    print("exit code 1")

也可以对错误类型进行举例，为该类型错误则运行except语句，其余的软件可报错。用这种方法可以避免except语句过于广泛。

具体报错类型可以详见官方开发文档。通用报错名称名为：Exception

try:
    for i in xx:
        pass
except NameError:
    print("exit code 1")

except语句可以拥有多个，但最广泛的except需要放在最后一个。

try:
    a = b
    print(a)
except SyntaxError:
    print("SyntaxERROR")
except NameError:
    print("NameERROR")

except语句可以把报错描述输出

try:
    a = b
    print(a)
except Exception as e:  # 把报错命名为e
    print(f"Erro : {e}")

把except报错类型输出，这里有用到Python内置函数 repr()

repr()：会返回一个对象的 string 格式。

try:
    a = b
    print(a)
except Exception as e:  
    print(repr(e)) # 给出完整描述
    print(repr(e).split('(')[0])  # 使用split提取把报错类型提取出来

try…except…else语句

上面我们说了如果程序运行出错就执行except，那么如果没出错我们应该也有一种语法去接收没有报错的写法。

接下来我们将讲的else语句就是写：如果没报错，执行else

try:
    b = 0
    a = b
    print(a)
except Exception as e:  
    print(repr(e))
else:
    print("No error")

try…except…finally语句

写了错或不错的写法，那么现在是剩下不管会不会出错，都会执行的语句

finally语句则是用于 ： 无论程序报不报错，都将要执行的语句

try:
    b = 0
    a = b
    print(a)
except Exception as e:  
    print(repr(e))
else:
    print("No error")
finally:
    print("Finish!")

Python高级知识拓展 **选学

接下来为Python一些高级使用方法，本处将讲述两种：条件表达式、条件生成式(推导式)；这些方法可以减少我们许多代码编辑工作，但较复杂。选学

（Python高级知识不仅为这2个，还有例如面向对象封装、闭包，迭代器装饰器等等，本处我们选讲条件表达式和生成式以便于我们方便我们实际使用）

条件表达式

我们通常的条件就是if…else语句组成，但通常都是if …else语句一句一行，所以我们这里讲述的就是将if else放置在一起简单判断。

# 条件表达式
a = 1
b = 2
c  =  a  if  a>b  else  b  # 先执行中间的if，如果返回True，就是if ，False为else。即，如果a>b成立，则c = a,否则c = b
print(c)

# 二维列表表达式
a = 1
b = 2
c  =  [b,a][a>b]  #实际是[b,a][False]，因为False被转换为0，所以是[2,1][0]，也就是[1];[b,a]判断结果 True 返回前面列表第二个， False返回第一个。
                       
print(c)

# bool 条件表达式（较难）
a = 1
b = 2
c  =  (a>b  and  [a]  or  [b])[ 0 ]  # 转化：False and [1] or [2]，因为and的优先级高于or，先算and
                                                    # False和[1] and之后是False，和[2]or之后成了[2]  and >> c = False = 1;  or > > >c=1 > > >b=2  
                                                    # True 和[1] and之后是[1]，但[1]和[2]or结果是[1]
print(c)

基础的3种类型写完了，你学废了嘛？这种写法理解即可，可用在读程序当中，也欢迎在实际写程序时运用，可以大大减少代码量。

条件生成式(推导式)

生成式 又称推导式、解析式，是 python 的一种独有特性。推导式是可以从一个数据序列构建另一个新的数据序列。

列表推导式

例如：当我们需要生成一个字典需要往里面存放内容时，我们通常使用for…in range()方法生成内容存放进去。那么我们现在讲的是如果更快的生成。

# 将10以内所有整数写入列表
lst = [ [ i for i in range(11) ]]
print(lst)  # 列表 i ，用for 循环往 列表i 里面赋值

# 将10以内所有整数的平方写入列表。
lst = [i**2 for i in range(1, 11)]
print(lst)

#  条件写入
# 构建一个列表,要求元素大于4
lst = [i for i in range(11) if i > 4]
print(lst)

# 有一列表 lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] ，取出 1/4/7 和 1/5/9元素
lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
lst1 = [lst[i][0] for i in range(len(lst))]
print(lst1)
lst2 = [lst[i][i] or i in range(len(lst))]
print(lst2)

在推动式当中，for循环还支持嵌套。

# 找到下列二维列表中名字含有两个‘e’的所有名字（有难度）
names = [
                 ['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
                 ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']
                ]
# 方法一: 普通方法
lst = []
for i in names:
    for j in i:
        if j.count('e') >= 2:
            lst.append(j)
print(lst)


# 方法二: 列表推导式方法
lst2 = [j for i in names for j in i if j.count('e') >= 2 ]
print(lst2)

综上所述，列表的推导式我们可以总结为

变量名 = [表达式 for 变量 in 列表 for 变量 in xxx]

变量名 = [表达式 for 变量 in 列表 if 条件]

字典推导式

字典推导式列表推导式思想的延续，语法差不多，只不过产生的是字典而已。

# 生成字典
dict_a = {key: value for key in 'python' for value in range(2)}
print(dict_a)

# 可以根据键来构造值
dict_b = {key: key * key for key in range(6)}
print(dict_b)

Python的常用的内置函数

建议配合菜鸟教程食用，这里不详细说使用方法和参数，可以去到网站上了解

与数学相关的内置函数

abs(a) : 求取绝对值。abs(-1)  
max(list) : 求取list最大值。max([1,2,3])
min(list) : 求取list最小值。min([1,2,3]) 
sum(list) : 求取list元素的和。 sum([1,2,3]) >>> 6
sorted(list) : 排序，返回排序后的list。
len(list) : list长度,len([1,2,3])
divmod(a,b): 获取商和余数。 divmod(5,2) >>> (2,1)
pow(a,b) : 获取乘方数。pow(2,3) >>> 8
round(a,b) : 获取指定位数的小数。a代表浮点数，b代表要保留的位数。round(3.1415926,2) >>> 3.14
range(a[,b]) : 生成一个a到b的数组,左闭右开。 range(1,10) >>> [1,2,3,4,5,6,7,8,9]

与类型转化相关的内置函数

int(str) : 转换为int型。int('1') >>> 1
float(int/str) : 将int型或字符型转换为浮点型。float('1') >>> 1.0
str(int) : 转换为字符型。str(1) >>> '1'
bool(int) : 转换为布尔类型。 str(0) >>> False str(None) >>> False
bytes(str,code) : 接收一个字符串，与所要编码的格式，返回一个字节流类型。bytes('abc', 'utf-8') >>> b'abc' bytes(u'爬虫', 'utf-8') >>> b'\xe7\x88\xac\xe8\x99\xab'
list(iterable) : 转换为list。 list((1,2,3)) >>> [1,2,3]
iter(iterable)： 返回一个可迭代的对象。 iter([1,2,3]) >>> <list_iterator object at 0x0000000003813B00>
dict(iterable) : 转换为dict。 dict([('a', 1), ('b', 2), ('c', 3)]) >>> {'a':1, 'b':2, 'c':3}
enumerate(iterable) : 返回一个枚举对象。
tuple(iterable) : 转换为tuple。 tuple([1,2,3]) >>>(1,2,3)
set(iterable) : 转换为set。 set([1,4,2,4,3,5]) >>> {1,2,3,4,5} set({1:'a',2:'b',3:'c'}) >>> {1,2,3}
hex(int) : 转换为16进制。hex(1024) >>> '0x400'
oct(int) : 转换为8进制。 oct(1024) >>> '0o2000'
bin(int) : 转换为2进制。 bin(1024) >>> '0b10000000000'
chr(int) : 转换数字为相应ASCI码字符。 chr(65) >>> 'A'
ord(str) : 转换ASCI字符为相应的数字。 ord('A') >>> 65

与特殊功能相关的内置函数

eval() : 执行一个表达式，或字符串作为运算。 eval('1+1') >>> 2
exec() : 执行python语句。 exec('print("Python")') >>> Python
filter(func, iterable) : 通过判断函数fun，筛选符合条件的元素。 filter(lambda x: x>3, [1,2,3,4,5,6]) >>> <filter object at 0x0000000003813828>
map(func, *iterable) : 将func用于每个iterable对象。 map(lambda a,b: a+b, [1,2,3,4], [5,6,7]) >>> [6,8,10]
zip(*iterable) : 将iterable分组合并。返回一个zip对象。 list(zip([1,2,3],[4,5,6])) >>> [(1, 4), (2, 5), (3, 6)]
type()：返回一个对象的类型。
id()： 返回一个对象的唯一标识值。
hash(object)：返回一个对象的hash值，具有相同值的object具有相同的hash值。 hash('python') >>> 7070808359261009780
help()：调用系统内置的帮助系统。
isinstance()：判断一个对象是否为该类的一个实例。可以用来判断数据类型
issubclass()：判断一个类是否为另一个类的子类。
globals() : 返回当前全局变量的字典。
next(iterator[, default]) : 接收一个迭代器，返回迭代器中的数值，如果设置了default，则当迭代器中的元素遍历后，输出default内容。
reversed(sequence) ： 生成一个反转序列的迭代器。 reversed('abc') >>> ['c','b','a']

常用的内置函数使用方法

map()函数

map函数的参数是

map（function，iterable，……）
其中，第一个参数是函数的名称，第二个参数是表示支持迭代的容器或者迭代器。

map函数的作用是：以参数序列中的每个元素分别调用function函数，把每次调用返回的结果保存为对象。

专业的来说的map函数会根据提供的函数对指定的序列做映射。字面意思是，可以把一个内容，批量修改转化成另外一个内容

map函数的转化方式是，提供一个转化方法的函数，再提供待转化的内容

map函数转化出来的结果是一个对象，既然是对象，你爱TA，你想得到TA，那么就需要一个去挽留住TA。用列表或元组(字典、集合)去留。

例如，将一个存有数字的列表转为字符串数字的列表

lst = [1,2,3,4,5,6,7,8,9]
# 普通的转化方法：
for i in range(len(lst)):
    lst[i] = str(lst)

# 使用mpa函数的转化方法：
lst = list(map(lambda x:str(x),lst))

filter()函数

filter函数的参数是

filter（function，iterable）
第一个参数是函数的名称，第二个参数表示的是序列，支持迭代的容器或者迭代器。

filter函数的作用主要是：对一个指定内容序列进行筛选操作；

filter函数的转化方式同理，还是提供一个转化方法函数，再提供转化的内容；

filter函数转化出来的结果是一个对象，既然是对象，深爱过，那么就挽留住TA，怎么留呢？同理用列表或元组(字典、集合)去留。

例如，筛选出一个列表大于5的数字

lst = [1,2,3,4,5,6,7,8,9]
# 普通转化方法：
for i in range(lst):
    if lst[i]<5:
        del lst[i]
        
# 使用filter函数的筛选方法
print(list(filter(lambda x:x>5,lst)))

Python小知识

Python是脚本语言;

Pythonr如果输出内容乱码须在开头加上：# -- coding:utf-8 --;

Python支持函数式编程、面向对象的编程（本课不涉及）;

Python在人工智能（机器学习、深度学习）、数据分析和网络爬虫上很有优势。掌握后看电视下载文献轻而易举。接单收益大;

Python 有3种结构：顺序结构（由上至下）、选择结构（分支结构）、循环结构;

Python非常注重缩进格式，千万要注意缩进格式。通常一个Tab键为一段进行区域，按Tab键快速进行，Tab和空格不能共用;

Python语句通常有缩进的语句都需要在即将开始进行时加上冒号[:];

Python中一个等号 = 是赋值，两个等号 == 是相等；

Python条件成立：非零整数（1）;

Python条件不成立：0;

Python提取特定内容用切片操作，切片可以运用到许多方面的内容要掌握;

Python判断条件用if-elif-else进行判断;

Python引入模块时，使用import 模块名;

Python引入模块遵循即用即取，尽量不多取一瓢水;

Python引入模块时，部分功能可能无法及时提取时，from 模块名 import 模块功能，可以精准提取出该模块内的该功能;

Python引入模块时，from 模块名 import * 意思为引入该模块所有功能，但加大内存，且部分隐藏功能可能无法及时提取;

Python引入string模块，string.ascii_letters + string.digits可以导入所有字母和数字;

Python函数的return语句可写可不写，如果需要返回内容就用return。如果一定想规范多写 return 0，可以，但没必要;

Python函数的return语句可以返回表达式、变量、文本内容等内容，且可以传回多个内容；

Python函数定义参数，定义多少个传多少个，除非有特别声明，传入的值可改变已固定的参数值；

Python用print输出时，在括号内加上end = “内容” 意思为以 改内容结尾；

Python用print输出时，括号内不填内容表示直接换行;

Python的print输出语句同样可以作为文件写入操作，且不需要添加换行符完成换行：print(“内容”,file = 文件名);

Python的replace语句可以替换掉字符串内的对应内容：操作语句名称.replace(“需替换的内容”,“替换为…”);

Python的strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列;

Python中使用 变量名称.isalpha()、.isspace()、.islower()、.isdigit()可以对应判断是否为中英字符、空格、小写、数字;

Python中使用 isinstance()可以判断内容是否为指定数据类型：isinstance(变量名称,判断的数据类型);

Python的sfor 和 while 循环，同等情况下，优先使用for循环会更方便;

Python让一个程序运行n次，配合for range可以更好操作：for i in range(n);

Python的while True可以让程序一直运行下去，如果需要退出请记得使用break语句，否则whlie True下的语句无法使用;

Python中可以用.split()方法分割字符串内容，默认为空格，分割转化后存入列表当中。

Python中提取报错提示用except Exception as e，输出 变量 的内容;

Python中提取报错类型用except Exception as e, 输出 repr(e).split(’(’)[0];

Python中提取完整报错用except Exception as e , 输出 repr(e);

Python中获取当前计算机时间，引入datetime模块，

from datetime import datetime 
time = datetime.now()    # 格式化时间字符串，输出格式化后的当前日期字符串，下面的格式为 2021-06-11 15:16:20   
date_time = time.strftime('%Y-%m-%d %H:%M:%S')  
print(time)    
print(date_time)             

Python计算时间差 用两个datetime.datetime(y,m,d) 最后(day2 - day1).days;

Python中任何时候都要用英文状态输入法输入，

Python中求n位数的个位数的数字n // 1 % 10;

Python中求n位数的十位数的数字n // 10 % 10;

Python中求n位数的百位数的数字n // 100 % 10;

Python中求n位数的千位数的数字n // 1000 % 10;以此类推;

在编程中一个简单常用的的排序交换法（冒泡排序法）：交换a b的值，用t做中间变量，则有t=a,a=b,b=t；但在Python中你可以a,b=b,a

在编程中，在得到一项编程以后先查看要求是什么，再思考程序需要在什么时候开始，该需要什么才实现这些功能。结合生活流程思考；

在编程中，遇到报错不要紧张，先去查看错误区域在哪再进行修改或者请教他人。遇事不决复制粘贴，复制粘贴才是编程的真谛！

在编程中，程序测试分多个版本，基本上第一个版本写的程序都是在写bug，习惯了就不会大惊小怪了；

Python小知识不仅仅这些，需要你去多多实践去发现操作，就像你研究一个角色如何连招最大输出。实践是检验真理的唯一标准；

COPYRIGHT @CAIXYPROMISE-2020-LIKE*FOREVEVER