【学习笔记】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)

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

NameError                                 Traceback (most recent call last)

 in 
      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:  # 区域A  开始
    print('执行if !')
    print('if语句执行完成！')  # 区域A 结束
    if a=>10:  # 区域B 开始
        print()  # 区域B 结束
print('Process finished with exit code 0.')  # 公共区域

输出语句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 = 'hhhh'
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')

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

print('back\bspace')

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

print(r'un\nknow')

input()输入语句

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

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

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

123
use_input是123

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

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

请输入一个数字：123
请输入一个数字：12
135
num1类型是：

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

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

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

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

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

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

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

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

123
['123']

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

print(a)
print(b)

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

123 123
123
123

原生字符串也使用.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))

123

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

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

10

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

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

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

3+1
4
5*5
25

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

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

3

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

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

Hello Everyone!

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

运算符讲解

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

算术运算符

＋ - * / // % ** 对应加减乘除。 // 为整除结果，抹零取整。 %是第一次除下去以后，取余数结果。**是乘方运算

比较运算符

< <= > >= != 对应比较符号，!= 为 非等于

布尔运算符

and or not in (not in) 对应英文翻译，5个

赋值运算符

== += -= *= /= //= %= 其中 == 是相等，+=是例如a = a+n，后面同理。

判断语句: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)
if a > 5:  # 由上至下
    pass
elif a > 8:  # elif 需写出判断成立条件
    pass
else:  # else 是if 和 elif语句都不成立时，执行else语句。可以没用else语句，均不成立则跳出。
    pass

10

range()生成数 语句

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

for 循环语句

1、定义一个常量，将已有数据赋予给这一个定义的常量中

格式：for 新的变量名称 in 从哪里赋予新的变量:

word ='Hello'
for i in word:
    print(i)

H
e
l
l
o

2、n次执行一段代码命令可以结合range：for i in range(n):

for i in range(10):
    print(f"第{i+1}次运行")
    if i == 10:
        print("Done")

while 循环语句

while循环语句同for循环道理一致，但while更加直观的写出循环条件，当条件不成立时则跳出结果，且需要更新变量。

格式：while 成立条件: 其中，while True无限循环。

n =0
while n<=10:
    n+=1
    pass

切片操作

切片操作可以用在我们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的方法非常简单，使用中括号[ ]把需要放在容器里面的元素括起来，就定义了一个列表。

[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)

{'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():
    

  File "", line 12
    
    ^
IndentationError: expected an indented block

添加/更改 字典内的数据

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

添加/更改的方法：字典名称【填入/更改的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)

(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

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

同列表的方法一样，用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)

{'Alice', 'David', 'Ellena', 'Candy', 'Bob'}
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)

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

批量添加内容

批量添加内容，可以用“.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)

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

删除set集合内的数据

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

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

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

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

KeyError                                  Traceback (most recent call last)

 in 
      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)

{'Jenny', 'Alice', 'Ellena', 'Candy'}

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

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

set()

函数

什么是函数？

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

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

用函数做什么？

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

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

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

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

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

函数的声明

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

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

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

无需传入参数的函数

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

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

Hello, This is a example function!!

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

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

30

需要传入参数的函数

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

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

未定义参数的函数

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

# 如果需要用到函数外围的变量，而不想传参时，需要用到global关键字定义全局变量，程序会遍历整个程序寻找该变量，并且得到其的值
a = 10
def t():
    global a
    a +=1
t()
print(a)

30
11

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

已定义参数的函数

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

  File "", line 2
    def calc(a,b=20,c):  # 默认定义好一个参数的值，则可以无需传入指定数量的参数，但必须放置在最右边
                     ^
SyntaxError: non-default argument follows default argument

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

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

可变长度的参数函数

元组存储的可变参数函数

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

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

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

(1, 2, 3, 4, 5, 6, 7)

字典存储的可变参数函数

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

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

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

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

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

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))

30

lambda可用于调用多个函数

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

# 例如


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

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

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

Hello World Python




[None, None, None]

程序运行略过：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")

exit code 1

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

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

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

exit code 1

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

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

123

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

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

123

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

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

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

123

try…except…else语句

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

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

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

0
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!")

0
No error
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)

2

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

2

# 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)

2

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

条件生成式(推导式)

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

列表推导式

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

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

[[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]]

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

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

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

[5, 6, 7, 8, 9, 10]

# 有一列表 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)

[1, 4, 7]
[1, 5, 9]

在推动式当中，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)

['Jefferson', 'Wesley', 'Steven', 'Jennifer']
['Jefferson', 'Wesley', 'Steven', 'Jennifer']

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

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

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

字典推导式

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

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

{'p': 1, 'y': 1, 't': 1, 'h': 1, 'o': 1, 'n': 1}

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

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

对应还有集合推导式，欢迎敬请发现体验噢！

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；

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

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

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

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

• Python入门知识就差不多到这里结束了，但当你能灵活运用这些内容时，你的水平不再是基础入门啦！

本文写到这里就要结束啦，很高兴我们在这里再次相遇！

本文是Python的基础入门笔记。但Python的学习并不止步如此。学习路漫漫，希望在看这篇文章的你每一天都有新的进步，祝你也祝我哈哈哈！~

本文是笔者的学习笔记，如有纰漏或错误之处还希望能在评论区指出，让我们一起进步吧！~

创作不易，如果你觉得本文对你起到帮助，别忘了点赞收藏+关注噢。你的鼓励就是我的继续创作的动力，后续我也会继续分享我的学习经历以及许多有趣的Python或C语言的编程项目噢。