一、Python的基础语法知识
1.1 变量
变量是一个代号，它代表的是一个数据。
变量名可以由任意数量的字母、数字、下划线组合而成，但不可以数字开头。
数据类型的查询
name = 'Tom'
number = 88
print(type(name)) #<class 'str'>
print(type(number)) #<class 'int'>数据类型的转化
#str()函数能将数据转换成字符串。还有int()、float()函数。
#int()函数转换浮点型数字，直接舍去小数点后面的数，保留整数部分。
a = 88
b = str(a)
print(type(a)) #<class 'int'>
print(type(b)) #<class 'str'>1.2数据类型
数字（int）
正整数、负整数、0。
浮点型数字（float）
带有小数点的数字。
字符串（string）
由字符连接起来的组合。
你也可以左键选中我们需要注释的代码，松开，按：Ctrl+/，就完成相同效果注释。（没用）
单引号和双引号不能跨行使用，三重引号可以跨行，并且会保留字符串中的格式。
print(520) #整型数字，可参与算数运算
print('520') #字符串，不可参与算数运算字符串 + 是拼接， *是 复制 ，-和/不行
a = 'Hello','CSDN'
b = 'Hello''CSDN'
c,d= 'Hello','CSDN'
print(a) #('Hello', 'CSDN')
print(b) #HelloCSDN
print(c,d) #Hello CSDN
print(c+d) #HelloCSDN
print(b[0:-2]) #HelloCS
print(c[0:-3]) #He
print(d[0:-1]) #CSD
print(c*2,d*2) #HelloHello CSDNCSDN
print((c+d)*2) #HelloCSDNHelloCSDNe='Love CSDN 1314'
print(e[0],e[5]) #L C
#输出指定索引位置的字母
print(e[0],e[-2],e[3]) #L 1 e
#Python与C语言字串符不同的地方在于Python字串符是不可以被改变的，
#如果向一个指定索引赋值，那么将会错误如果你想换行转义输出，你可以在要转义的字串符之间加个\n，但在字串符前加个r将会是原字串符输出。
可以使用 \ 作为转义字符，通过转义字符，可以在字符串中使用一些特殊的内容
\' 表示'
\" 表示"
\t 表示制表符
\n 表示换行符
\\ 表示反斜杠
\uxxxx 表示Unicode编码print('Hello,\nCSDN')
print(r'Hello,CSDN')#加了r后转义字符失效
运行结果：
Hello,
CSDN
Hello,CSDN列表（List）
列表名 = [元素1, 元素2, 元素3, ……]在列表中，数值可以类型不同，但是除数字以外其他任何数值都必须要用单引号括起。
在其他语言中通常叫做数组，专门用来存储一组数据。
#第一种方式
name_list = [] OR name_list = ['tom','jack']
#第二种方式
data_list = list()遍历
name = ['张三', '李四']
for i in name:
print(i)统计
列表的元素个数
a = len(class1)
print(a) #5提取
列表的多个元素——列表切片
#左闭右开
class1 = ['孙悟空','沙和尚','唐僧','猪八戒','观音菩萨']
a = class1[1:4]
print(a) #['沙和尚','唐僧','猪八戒']
a = class1[1:] #提取第2个到最后一个
a = class1[-3:] #提取倒数第3个到最后一个
a = class1[:-2] #提取倒数第2个之前的所有元素，不包括倒数第2个查询
列表可以用索引来用数据
name_list = ['张三', '李四']
print(name_list[0]) # 张三
print(name_list[1]) # 李四count
data_list = ['python', 'java', 'python', 'php']
print(data_list.count("python")) #2插入
append(数据)
val_list = ["Web自动化", "UI自动化", "接口自动化"]
val_list.append("APP自动化")
print(val_list)
# ['Web自动化', 'UI自动化', '接口自动化', 'APP自动化']
ps：
可以插入的各种不同类型的数据，比如数字 字典 元组insert(位置,数据)
abc = [ ‘yinsheng’, ‘jiayou’, 1111, (11, 22, 33), {‘abc’: 456} ]
abc.insert(0,{“key”:1})
print(abc)
#[ {‘key’: 1}, ‘yinsheng’, ‘jiayou’, 1111, (11, 22, 33), {‘abc’: 456} ]extend()
使用新的序列来扩展当前序列，需要一个序列作为参数，它会将该序列中的元素添加到当前列表中
stus.extend(['唐僧','白骨精'])
相当于
stus += ['唐僧','白骨精']删除
remove()
# 删除指定值得元素，如果相同值得元素有多个，只会删除第一个
stus = ['孙悟空','猪八戒','沙和尚','唐僧','猪八戒']
stus.remove('猪八戒')
print(stus) #['孙悟空','沙和尚','唐僧','猪八戒']pop (列表索引号)
val_list = ["Web自动化", "UI自动化", "接口自动化"]
val = val_list.pop(0)
print(val, val_list)
# web自动化，['UI自动化', '接口自动化']
ps：
不指定位置号，那么默认删除最后一个clear()
stus = ['孙悟空','猪八戒','沙和尚','唐僧']
stus.clear() #清空序列 []排序
reverse() 反转列表
my_list = [10,1,20,3,4,5,0,-2]
print('修改前',my_list) #[10, 1, 20, 3, 4, 5, 0, -2]
my_list.reverse()
print('修改后',my_list) #[-2, 0, 5, 4, 3, 20, 1, 10]sort() 默认reverse=false
sort(reverse=false) #升序
sort(reverse=true) #降序
val_list = [8, 100, 30, 10, 40, 2]
val_list.sort()
print(val_list) #[2, 8, 10, 30, 40, 100]
val_list.sort(reverse=True)
print(val_list) #[100, 40, 30, 10, 8, 2]sorted() 临时排序
val_list = [8, 100, 30, 10, 40, 2]
b= sorted(val_list)
print(val_list) #[8, 100, 30, 10, 40, 2]
print(b) #[2, 8, 10, 30, 40, 100]嵌套
student_list = [ ["张三", "18", "功能测试"], {"key":1,"key1":2}, (11,222,333) ]
print(student_list[1]["key1"]) #2
print(student_list[0][1]) #18
print(student_list[2][1]) #222列表与字符串的相互转换
#引号中的内容是元素之间的连接符，如“，” “；”等
#将class1转换成一个用逗号连接的字符串
class1 = ['孙悟空','沙和尚','唐僧','猪八戒','观音菩萨']
a = ','.join(class1)
print(a) #孙悟空,沙和尚,唐僧,猪八戒,观音菩萨#使用空格作为分隔符，将字符串‘hi hello world’拆分成列表
a = 'hi hello world'
print(a.split(' ')) #['hi', 'hello', 'world']例题
a = ['a','b','c',3]
b = [4,7,'love','to','lwl',',','never','change']
print(a,b) #['a', 'b', 'c', 3] [4, 7, 'love', 'to', 'lwl', ',', 'never', 'change']
print(a[0:1:3]) #['a']
#输出指定列表被切割后的指定数据
print(b[1:7]) #[7, 'love', 'to', 'lwl', ',', 'never']
print(a[3]) #3
#输出指定索引搜索的数据
print(b[7]) #change
a[0:3]='A','B','C'#修改列表中指定数据，即可以直接修改
print(a) #['A', 'B', 'C', 3]
b.append(347) #append()函数用于在制定列表末尾添加新数值
print(b) #[4, 7, 'love', 'to', 'lwl', ',', 'never', 'change', 347]
a[1]=[] #移除a列表中指定索引数据
print(a) #['A', [], 'C', 3]
print('a列表数据个数:',len(a),'b列表数据个数:',len(b))#a列表数据个数: 4 b列表数据个数: 9
#len()函数用于统计列表数据个数
c=[0,1] #生成一个嵌入式列表
d=[2,3]
e=[c,d]
print(e) #[[0, 1], [2, 3]]和列表list 几乎差不多 只是不可以修改 但是这个不可以修改指的是指向永远不变。
当元组不是空元组时，括号可以省略。
如果元组不是空元组，它里边至少要有一个。
#第一种方式
user_info = () OR name_list = ('zhangsan',18,1.75)
#第二种方式
info_tuple = tuple()
ps:元组中只包含一个元素时，需要在元素后面添加逗号
如 data=（1，）索引
tuple1 = (1, 2, 3)
print(tuple1[1]) #2count
tuple1 = (1, 2, 3)
print(tuple1.count(3)) #1解包
元组的特殊用法: 交换两个变量的值
num1 = 100
num2 = 200
num2,num1 = num1,num2
print(num1) #200
print(num2) #100
ps:
1.在Python中可以使用对应数据个数的变量，获取对应元组数据中的每一个元素
2.在Python中定义多个元素的元组数据时，小括号可以省略
3.借助以上两个特性，可以通过元组快速实现交换两个变量的值解包
my_tuple = 10 , 20 , 30 , 40
a , b , *c = my_tuple
print(a,b,c) #10 20 [30, 40]
a , *b , c = my_tuple
print(a,b,c) #10 [20, 30] 40
*a , b , c = my_tuple
print(a,b,c) #[10, 20] 30 40字典（Dictionary）
字典[键]=值
字典名 = {键1:值1, 键2:值2, 键3:值3……}字典的值可以是任意对象。
字典的键可以是任意的不可变对象（int、str、bool、tuple ...），但是一般我们都会使用str。
字典的键是不能重复的，如果出现重复的后边的会替换到前边的。
test = dict()
test2 = {}
d = dict(name1='孙悟空',age1=18,gender1='男')
print(d) #{'name1': '孙悟空', 'age1': 18, 'gender1': '男'}
#利用双值子序列
d = dict( [('name','孙悟饭'),('age',18)] )
print(d) #{'name': '孙悟饭', 'age': 18}增加和修改
info = {
"name": "tom",
"age": 18
}
info["salary"] = 100000
print(info) # {'name': 'tom', 'age': 18, 'salary': 100000}pop(键) 删除
info = {
"name": "tom",
"age": 18,
"gender": "男" }
info.pop("gender")
print(info) # {'name': 'tom', 'age': 18}get(键) 查询
info = {
"name": "tom",
"age": 18,
"gender": "男" }
print(info.get("name")) # tom
print(info.get("abc")) # None遍历
for key in 字典.keys()
#遍历得到所有键名
info = {
"name": "tom",
"age": 18,
"gender": "男" }
for key in info.keys():
print(key)for value in 字典.values():
#遍历得到所有的键对应的值
info = {
"name": "tom",
"age": 18,
"gender": "男" }
for value in info.values():
print(value)for k, v in 字典.items():
#遍历得到所有的键和值
info = {
"name": "tom",
"age": 18,
"gender": "男" }
for k, v in info.items():
print(f"key={k} value={v}")
for i in info:
print(i + ':' + str(info[i]))
运行结果：
key=name value=tom
key=age value=18
key=gender value=男
name:tom
age:18
gender:男常用
添加
setdefault(key, default]) 可以用来向字典中添加key-value
#如果key已经存在于字典中，则返回key对应的value值，不会对字典做任何操作
#如果key不存在，则向字典中添加这个key，并设置value
d = dict([('name','孙悟饭'),('age',18)])
result = d.setdefault('name1','猪八戒')
result2 = d.setdefault('name','11111')
print(result) #猪八戒
print(result2) #孙悟饭
print(d) #{'name': '孙悟饭', 'age': 18, 'name1': '猪八戒'}更新
update()
#将其他的字典中的key-value添加到当前字典中
#如果有重复的key，则后边的会替换到当前的
d = {'a':1,'b':2,'c':3}
d2 = {'d':4,'e':5,'f':6, 'a':7}
d.update(d2)
print(d) #{'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}删除
del
d = {'a': 7, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
del d['a']
print(d) #{'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6}
del d['e']
print(d) #{'b': 2, 'c': 3, 'd': 4, 'f': 6}popitem()
#随机删除字典中的一个键值对，一般都会删除最后一个键值对
#删除之后，它会将删除的key-value作为返回值返回
#返回的是一个元组，元组中有两个元素，第一个元素是删除的key，第二个是删除的value
#当使用popitem()删除一个空字典时，会抛出异常 KeyError
d = {'b': 2, 'c': 3, 'd': 4, 'f': 6}
result = d.popitem()
print(result) # ('f', 6)
print(d) # {'b': 2, 'c': 3, 'd': 4}clear()
d = {'b': 2, 'c': 3, 'd': 4}
d.clear() #{}复制
copy()
# 该方法用于对字典进行浅复制
# 复制以后的对象，和原对象是独立，修改一个不会影响另一个
# 注意，浅复制会简单复制对象内部的值，如果值也是一个可变对象，这个可变对象不会被复制 意味着修改了这个可变对象的值之后 两个地方的值均变化 因为它不独立
d = {'a':{'name':'孙悟空','age':18},'b':2,'c':3}
d2 = d.copy()
print(d2) #{'a': {'name': '孙悟空', 'age': 18}, 'b': 2, 'c': 3}
d2['a']['name'] = '测试一想'
d2['b']=6
print(d2) #{'a': {'name': '测试一想', 'age': 18}, 'b': 6, 'c': 3}
print('d = ',d , id(d)) #d = {'a': {'name': '测试一想', 'age': 18}, 'b': 2, 'c': 3} 2363954785808
print('d2 = ',d2 , id(d2)) #d2 = {'a': {'name': '测试一想', 'age': 18}, 'b': 6, 'c': 3} 2363954786168in not in
元组（Tuble）
元组的定义和使用方法与列表非常类似，区别在于定义列表是使用的符号是中括号[]，定义元组时使用的符号时小括号()，并且元组中的元素不可修改。但是这个不可以修改指的是指向永远不变。
当元组不是空元组时，括号可以省略。
如果元组不是空元组，它里边至少要有一个。
#第一种方式
user_info = () OR name_list = ('zhangsan',18,1.75)
#第二种方式
info_tuple = tuple()
ps:元组中只包含一个元素时，需要在元素后面添加逗号
如 data=（1，）索引
tuple1 = (1, 2, 3)
print(tuple1[1]) #2count
tuple1 = (1, 2, 3)
print(tuple1.count(3)) #1解包
元组的特殊用法: 交换两个变量的值
num1 = 100
num2 = 200
num2,num1 = num1,num2
print(num1) #200
print(num2) #100
ps:
1.在Python中可以使用对应数据个数的变量，获取对应元组数据中的每一个元素
2.在Python中定义多个元素的元组数据时，小括号可以省略
3.借助以上两个特性，可以通过元组快速实现交换两个变量的值解包
my_tuple = 10 , 20 , 30 , 40
a , b , *c = my_tuple
print(a,b,c) #10 20 [30, 40]
a , *b , c = my_tuple
print(a,b,c) #10 [20, 30] 40
*a , b , c = my_tuple
print(a,b,c) #[10, 20] 30 40集合（Set）
集合时一个无序的不重复序列，可使用大括号{}来定义，也可以使用set()函数来创建集合。
a = set()
print(type(a))
a = {1,3,4}
print(type(a))将字符串、列表、元组、字典转化为集合
s = set('hello')
print(s) # {'l', 'o', 'e', 'h'}
s = set([1,2,3,4,5,1,1,2,3,4,5])
print(s) # {1, 2, 3, 4, 5}
s = (1,2,3,4)
print(set(s)) # {1, 2, 3, 4}
s = set({'a':1,'b':2,'c':3})
print(s) # {'a', 'b', 'c'}常用
in not in
使用in和not in来检查集合中的元素
s = {'a' , 'b' , 1 , 2 , 3 , 1}
print('c' not in s) #True
print('a' in s) #Trueadd()
s = {'a' , 'b' , 1 , 2 , 3 , 1}
s.add(10)
print(s) #{1, 2, 3, 'a', 10, 'b'}update()
update() 将一个集合中的元素添加到当前集合中
update()可以传递序列或字典作为参数，字典只会使用键
s = {'a' , 'b' , 1 , 2 , 3 , 1}
s2 = set('hello')
s.update(s2)
print(s) #{1, 2, 3, 'o', 'e', 'a', 'h', 'b', 'l'}
s.update((10,20,30,40,50))
print(s) #{1, 2, 3, 'o', 40, 10, 'e', 'a', 'h', 50, 20, 30, 'b', 'l'}
s.update({10:'ab',20:'bc',100:'cd',1000:'ef'})
print(s) #{1, 2, 3, 100, 'o', 40, 10, 'e', 1000, 'a', 'h', 50, 20, 30, 'b', 'l'}pop()
pop()随机删除并返回一个集合中的元素
s = {'a' , 'b' , 1 , 2 , 3 , 1}
result = s.pop()
print(result) #1
print(s) #{2, 3, 'a', 'b'}remove()
s = {'a' , 'b' , 100 , 2 , 3 , 100}
s.remove(100)
print(s) # {2, 3, 'b', 'a'}clear()
copy()
1.3 运算符
算数运算符和字符串运算符
+:加法，两个变量相加求和
-:减法，两个变量相减求差
*：乘法，变量相乘求积
/：除法，变量相除求商
**：次方，求变量（a）的n次幂->(a)ⁿ，可以用pow()函数代替
//：整除，取除法后的整数部分
%：取模，得到除法结果第一位余数比较运算符
< ：小于，用于判断变量是否小于常量
> ： 大于，用于判断变量是否大于常量
>= ：大于或等于，用于判断变量是否大于或等于常量
<= ：小于或等于，用于判断变量是否小于或等于常量
== ：等于，用于判断两个常量是否相等
!= ：不等于，用于判断两个常量是否不等于赋值运算符
逻辑运算符
and：逻辑与，左右都为True才返回Ture
or：逻辑或，左右都为False才返回False
not：逻辑非，右侧的值为True时返回False，为False时返回True1.4控制语句
if语句
if条件：
代码
else：
代码if条件：
代码
elif条件：
代码
else：
代码for语句
class1 = ['李白', '王维', '孟浩然']
for i in class1:
print(i)for i in range(3) #0,1,2
print('第', i+1, '次')while语句
while条件：
需要重复的代码a = 1
while a < 3:
print(a)
a = a + 1
#第一次循环：a=2
#第二次循环：a=3
#第三次循环：a=4可以搭配True永久循环，PyCharm中【Ctrl+F2】可以强制停止。
1.5函数
函数就是把具有独立功能的的代码块组织成一个小模块，在需要时直接调用。
内置函数
Python的开发者已经编写好的函数，我们可以直接使用。
len()
可以统计列表的元素个数，字符串的长度/字符的个数
a = '123abc'
print(len(a)) #6字符串.replace（要查找的内容，要替换为的内容）
主要用于在字符串中进行查找和替换
a = '<em>面朝大海，</em>春暖花开'
a = a.replace('<em>', '')
a = a.replace('</em>', '')
print(a) #面朝大海，春暖花开字符串.strip()
主要用于删除字符串首尾的空白字符（包括换行符和空格）
a = ' 面朝大海 春暖花开 '
a = a.strip()
print(a) #面朝大海 春暖花开字符串.split('分隔符')
主要作用是按照指定的分隔符将字符串拆分为一个列表
today = '2020-04-21'
a = today.split('-')
print(a) #['2020', '04', '21']字符串.format(要格式化的值)
a = '{}, {}!'.format('Hello', 'Python')
print(a) #Hello, Python!自定义函数
用户按照需求自己编写的函数
函数的定义与调用
def 函数名（参数）：
实现函数功能的代码1.6 模块的导入
import语句导入法
会导入指定模块中的所有函数，使用于需要使用指定模块中的大量函数的情况。
import 模块名from语句导入法
用import语句全部导入后会导致程序运行速度较慢吗，将程序打包后得到的文件体积也会很大。from可以指定要导入的函数。
from 模块名 import 函数名#模块名或函数名很长
import numpy as np #导入NumPy模块，并将其简写为np
from math import factorial as fc #导入math模块中的factorial()函数，并简写为fc
from 模块名 import * = import 模块名
#优点：在调用模块中的函数时无需添加模块名前缀
#缺点：不能使用as保留字来简化函数名整理的好乱。。。。
引入：
(27条消息) Python入门教程(从小白到高级)(新版)_Python菜中菜的菜鸟的博客-CSDN博客_python教程
(37条消息) Python基础知识大全(适用于全面复习Python语法知识)_BRAVE_Fighting的博客-CSDN博客
2254
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
