一.基础知识
1.1 基础语法及编码规范
1.定义变量加if
#Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 \ 来实现多行语句sad
total = ['item_one','item_two','item_three',
'item_four','item_five']
或者: ha = 'hahaha' \
'hahaha'
name = 'xuexiaoqiang' --定义变量
if True: --如果定义正确
print(name) --打印变量内容(调用变量不能加"",''否则不会调用)
else:
print("no") --否则打印no:,py对于格式的要求比较严格.必须对齐
2.基础知识
#Python 中单引号 ' 和双引号 " 使用完全相同。
#反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。 如 r"this is a line with \n" 则 \n 会显示，并不是换行
#字符串可以用 + 运算符连接在一起，用 * 运算符重复
#Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。
`案例`
world = '字符串'
setnece = '这是一个句子'
paragraph = '这是一个段落'
print(world+setnece,paragraph);print('\n') #\n内置变量换行
str = '123456789'
print(str)
print(str[0:-1]) ##输出左边第一个至倒数第二个字符串
print(str[0]) ##输出左边第一个字符
print(str[0:5]) ##输出左边第一个到第五个字符
print(str[3:]) ##输出第三个至最后一个
print(str * 2) ##输出俩遍定义的字符串内容
print(str + '你好') ##输出定义的字符串+后方内容,无空格
print('-------------------------------------------')
print('hello\nnihao') ##输出hello并换行输出nihao
3.字符串
import sys; x = 'randoy'; sys.stdout.write(x + '\n')
#;同行内输入多个语句
#print()与sys.stdout.write()区别
1. stdout只能输出字符串，如果要输出数字，也需要先转成字符串形式的；print可以直接输出各种类型。
2. stdout输出结果后不自动换行；print会自动换行。
3. print默认调用了sys.stdout.write()方法将输出打印到控制台，也可通过file参数将输出打印到其他文件中
print
#print 默认输出是换行的，如果要实现不换行需要在变量末尾加上 end=""：
`案例`
x = 'a' ##x=a
y = 'b' ##y=b
print(x * 2) ##输出a重复2次
print(y +"哈哈") ##输出y哈哈
print('----------------')
print(x,end=" ") ##不换行输出x,y及 a b
print(y,end=" ")
print(" ") ##打印空行
4.模块导入
在 python 用 import 或者 from...import 来导入相应的模块。
将整个模块(somemodule)导入，格式为： import somemodule
从某个模块中导入某个函数,格式为： from somemodule import somefunction
从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc
将某个模块中的全部函数导入，格式为： from somemodule import *
`案例`
import sys ##引入sys系统模块
print('===Python import mode===') ##输出内容
print('命令参数为:')
for i in sys.argv: ##for循环sys内置函数(脚本名称及路径)
print(i) ##打印脚本路径
print('\n python 路径为',sys.path) ##换行输出python全部路径
from sys import argv,path ##引入sys模块中的argv和path模块,argv[0]是被调用的脚本文件名或全路径.
print('-----')
print('path:',path) ##输出路径为:path
编码规范
#定义变量时的大写字母为代码中的常量(及固定变量禁止修改),python允许在代码块中修改已有变量的内容
#变量名称需要有意义,慎用小写l和
1.2 基本数据类型
1.基本数据类型
`案例`
# -*- coding: cp-1252 -*-
counter = 100 --int(整形) || counter,miles,name = 100,1000.0,'rundob' #多种定义变量的方式
miles = 1000.0 --fload(浮点型)
name = "rundob" --字符串
print(counter,type(counter));print(miles,type(miles)) --;不换行输出指令,打印出前俩个变量的内容和类型
print("准备进行运算")
if True: --如果上方结果为真
sum1 = counter * 2+miles%10+200 --定义sum1=var(1)×2+var(2)的值,和10取余+200
print(sum1)
else:
print(name,type(name))
2.标准数据类型
不可变数据(3个):Number（数字）、String（字符串）、List（列表）
可变数据(3个):Tuple（元组）、Set（集合）、Dictionary（字典）
3.标准数据类型拓展
#number
python中支持: int、float、bool、complex（复数）
`案例`
a,b,c,d = 1,2.3,True,"asdasd+"
print(a,type(a),b,type(b),c,type(c),d,type(d))
if True:
print("ok","成功")
用isinstance来判断:
# coding:utf-8
haha = 123
print(isinstance(haha, int)) #为什么要加print,是将判断的结果输出,pycharm等工具无法输出判断结果,需要print出来
if True:
print(type(haha))
#isinstance和type的区别在于：
type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。
`案例`
#coding:utf-8
class A:
#pass ##Python pass 是空语句，是为了保持程序结构的完整性。pass 不做任何事情，一般用做占位语句
def __init__(self,x,y): ##定义俩个初始属性进行实例化
self.x = x ##定义变量self.x=x
self.y = y
class B(A): ##类ClassB继承类ClassA的方法和属性
print (isinstance(A(1,2),A)) ##打印出判断A中的子类(实例)是否为父类。注意格式需要进行缩进
print(type(A(1,2)) == A) ##判断A和父类A类型是否相同
print(isinstance(B(1,2),A)) ##判断B中的子类是否为A的继承类(子类)
print(type(B(1,2)) == A) ##type不考虑继承关系,判断B是否和A为相同类型
结果：
True
True
True
False
##Python3 中,bool是int的子类,True和False可以和数字相加,True==1、False==0 会返回 True，但可以通过is来判断类型。
`案例`
# coding:utf-8
print(issubclass(bool,int)) #issubclass方法用于判断参数 class是否是类型参数classinfo的子类
print(True == 1) #默认true=1
print(False == 0) #默认false=0
print(True + 1) #T=1，此处的true+1
print(False + 1) #False=0,此处的Fasle+1
print(1 is True) #结果为false,会向上获取结果
print(0 is False) #结果为false,会向上获取结果
4.del语法
#del语句用来删除一些对象引用
# coding:utf-8
var1 = 10
print(var1+100)
del var1 ##删除变量定义
var1 = 100 ##重新定义变量内容
print(var1)
1.3 数值运算
1.python可以直接进行运算,无需shell中的let (())等
# coding:utf-8
print( 5 + 4 )
print( 5 - 4 )
print( 5 * 4 )
print( 5 / 4 )
print( 5 // 4 ) ##除法得到整数
print( 5 % 4 ) ##取余
print( 5 ** 4 ) ##次方运算
print( -0 * 1 ) ##复数运算
#结果
9
1
20
1.25
1
1
625
#/ 返回一个浮点数，// 返回一个整数。
#在混合计算时，Python会把整型转换成为浮点数。
1.4 字符串
1.Python中的字符串用单引号 ' 或双引号 " 括起来，同时使用反斜杠 \ 转义特殊字符
索引值以 0 为开始值，-1 为从末尾的开始位置。
加号 + 是字符串的连接符， 星号 * 表示复制当前字符串，与之结合的数字为复制的次数。实例如下：
# coding:utf-8
str = "RanDo"
print(str)
print(str[0:-1]) ##输出第一个字符到倒数第二个字符
print(str[1:3]) ##输出第二个
print(str[2:]) ##输出str变量第三个字符到末尾
print(str+"str") ##输出str变量内容+str
print(str*2) ##输出变量字符串俩次
2.Python 使用反斜杠 \ 转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个 r，表示原始字符串：
# coding:utf-8
print("haha\nnima")
haha
nima
print(r"haha \n haha")
haha \n haha
3.反斜杠(\)可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者 '''...''' 跨越多行。
注意，Python 没有单独的字符类型，一个字符就是长度为1的字符串
# coding:utf-8
word = "python"
print(word[0],word[-1]\
,word[0:-3],word[-5:-3])
#Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = 'm' 会导致错误。
1.5 列表
1.List（列表） 是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。
列表是写在方括号 [] 之间、用逗号分隔开的元素列表。
和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。
列表截取的语法格式如下：
变量[头下标:尾下标]
`案例`
索引值以 0 为开始值，-1 为从末尾的开始位置。
t = ['a','b','c','d','e']
索引: 0 1 2 3 4
-5 -4 -3 -2 -1
#coding utf-8
#author "*****"
list = [ 'abc',786,2.23,'rundon',70.2 ]
tinylist = [123,'rundon']
print(list)
print(list[0]) --打印列表的第一个元素值.索引为0的值也就是abc
print(list[0:-3])
print(list[1:])
print(list+tinylist)
#与Python字符串不一样的是，列表中的元素是可以改变的：
#coding utf-8
#author "*****"
list = [ 123,'hah',0.1,'name' ]
list[0] = 9 #修改list列表中第0为的值
list[1:4] = [ 10 ,11 ,12 ,13 ] #修改2-末尾的值
print(list)
list[4] = "" #修改4的值为空
print(list)
#结果
[9, 10, 11, 12, 13]
[9, 10, 11, 12, '']
2.Python列表截取可以接收第三个参数，参数作用是截取的步长，以下实例在索引 1 到索引 4 的位置并设置为步长为 2（间隔一个位置）来截取字符串：
#coding utf-8
#author "*****"
def reversWords(input): #定义函数入口的内容为输入的内容
inputWords = input.split("=") #指定input的内容通过字符包含的=号分割
inputWords = inputWords[-1::-1] #重定义列表内容,最后一个到第一个倒着来,并且以1个=号进行分隔占位
output = ','.join(inputWords) #定义输出内容为,号为指定新分隔符,连接列表中的内容,将原有的=号替换为,号
return output #函数结束后返回output的内容
rw = reversWords(input("输入你要的数字:")) ##rw=执行函数,并交互输入内容
print(rw)
#结果
输入你要的数字:1=2=3=4=5
5,4,3,2,1
1.6 Tuple（元组）
1.元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。
元组中的元素类型也可以不相同：
#coding utf-8
#author "*****"
tuple = ('abc',123,0. 1,'haha')
print(tuple)
print(tuple[0:-1])
print(tuple[-1::-1]) ##倒着以1个布长进行分隔输出
print(tuple[0::2]) ##左侧开始计算0-末尾,以2个步长进行输出
#结果
('abc', 123, 0.1, 'haha')
('abc', 123, 0.1)
('haha', 0.1, 123, 'abc')
('abc', 0.1)
2.虽然tuple的元素不可改变，但它可以包含可变的对象，比如list列表。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则
string、list 和 tuple 都属于 sequence（序列）。
"""
字符串、列表、元组都是序列类型
支持索引、切片、遍历
"""
"""
元组tuple
一种类似列表的数据序列类型
不可变，不可以添加、删除、更新元素
用两个小括号包括，元素之间用逗号分隔
"""
问题：既然元组和列表这么像，为什么要有这个数据结构，需要元组的地方都用列表不就行了吗？
1.内容区别
元组是异质(一个元组内可存储不同数据类型的数值)、不同类型而列表是同质，相同类型。
#用一个元组表示一个人的信息people(id、name、age) 用一个列表表示很多人的信息列表[p1,p2,p3]
2.使用区别
元组更多用于拆包，列表用于循环遍历。元组pack和unpack：
#id,name,age = 1001, 'xiaoming', 20
#列表循环遍历：for s in students: print(s)
3.是否可变
元组内容不可变，列表内容可变。
#元组的不可变性质，代码更安全，如果是一个元组就放心的使用，不怕被更改,有些场景需要不可变的列表，比如字典的KEY要求不可变对象
1.7 set集合
1.集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。
创建格式：
parame = {value01,value02,...}
或者
set(value)
`案例`
#coding utf-8
#author "*****"
sites = {'Google','taobao','Runnob','Facebook','zhizu','Baidu'}
search = input("输入你要查询的内容:")
if search in sites :
print(f'{search} is in the sites')
exit(0)
else:
print(f'{search} is not in the sites')
exit(2)
`案例2-集合运算`
#set集合运算
a = set('我爱你呀')
b = set('我恨你呀')
print(a)
print( a - b ) #a和b的差集
print( a | b ) #a和b的并集
print( a & b ) #a和b的交集
print( a ^ b ) #a和b中不同时存在的元素
#结果
{'你', '爱', '呀', '我'}
{'爱'}
{'你', '爱', '我', '呀', '恨'}
{'你', '呀', '我'}
{'爱', '恨'}
1.8 Dictionary(字典)
1.字典（dictionary）是Python中另一个非常有用的内置数据类型。
列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用{ }标识，它是一个无序的键(key):值(value)的集合。
键(key)必须使用不可变类型。
在同一个字典中，键(key)必须是唯一的。
`案例`
# coding = utf-8
dict = {} #定义一个空字典
dict['one'] = "1-*****" #字典的第一个内容为名字
dict[2] = "2-哈拉少" #字典的第二个内容为哈拉少
#自定义字典的名称和内容
tinydict = {'name':'rando','code':1,'site':'www.baidu.com'}
print(dict['one']) #输出键为one的值
print(dict[2]) #输出键为 #也可也写为print(dict.get(2))
print(dict.keys()) #输出dict(字典)的键
print(dict.values()) #输出dict(字典)的值
print(tinydict.keys()) #输出所有键
print(tinydict.values())#输出所有值
2.构造函数 dict() 可以直接从键值对序列中构建字典如下
# coding = utf-8
print(dict([('Runoob',1),('Google',2),('Taobao',3)]))
print({x: x**2 for x in range (11)}) #该代码使用的是字典推导式.x的值为0,格式为x:x的二次方进行输出
print(dict(Runoob=1,Google=2,Taobao=3))
另外，字典类型也有一些内置的函数，例如 clear()、keys()、values()等。
注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。
3、创建空字典使用{ }。
1.9 Python数据类型转换
1.有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名即可
以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。
2.Python 数据类型转换可以分为两种：
`隐式类型转换 - 自动完成`
在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预。
以下实例中，我们对两种不同类型的数据进行运算，较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。
num_int = 3
num_flo = 2.5
num_new = num_int + num_flo
print(num_new,type(num_new))
#结果为5.5 <class 'float'>
#因为都属数值类型的内容,python会在内部进行隐式类型的转换
--较低数据类型（整数）就会转换为较高数据类型（浮点数）以避免数据丢失。(隐式类型转换)
`显式类型转换 - 需要使用类型函数来转换`
#整型和字符串类型运算结果会报错，输出 TypeError。 Python 在这种情况下无法使用隐式转换。但是，Python 为这些类型的情况提供了一种解决方案，称为显式转换。
在显式类型转换中，用户将对象的数据类型转换为所需的数据类型。 我们使用 int()、float()、str() 等预定义函数来执行显式类型转换。
code:
x = 123
x1 = '123'
x2 = 3.8
print(type(x),type(x1),type(x2))
x1_1 = int('123')
print(x1_1,type(x1_1))
x2_2 = int(3.8)
print(x2_2,type(x2_2))
x_0 = float(123)
print(x_0,type(x_0))
#结果
<class 'int'> <class 'str'> <class 'float'>
123 <class 'int'> #字符串转换为int(字符串必须以10为基数)
3 <class 'int'> #浮点型转换为整形只看第一位
123.0 <class 'float'> #整形转换为浮点型默认加.0
| 函数 |
描述 |
| int(x [,base]) |
将x转换为一个整数 |
| float(x) |
将x转换到一个浮点数 |
| complex(real [,imag]) |
创建一个复数 |
| str(x) |
将对象 x 转换为字符串 |
| repr(x) |
将对象 x 转换为表达式字符串 |
| eval(str) |
用来计算在字符串中的有效Python表达式,并返回一个对象 |
| tuple(s) |
将序列 s 转换为一个元组 |
| list(s) |
将序列 s 转换为一个列表 |
| set(s) |
转换为可变集合 |
| dict(d) |
创建一个字典。d 必须是一个 (key, value)元组序列。 |
| frozenset(s) |
转换为不可变集合 |
| chr(x) |
将一个整数转换为一个字符 |
| ord(x) |
将一个字符转换为它的整数值 |
| hex(x) |
将一个整数转换为一个十六进制字符串 |
| oct(x) |
将一个整数转换为一个八进制字符串 |
2 推导式
1.Python 推导式是一种独特的数据处理方式，可以从一个数据序列构建另一个新的数据序列的结构体。
Python支持各种数据结构的推导式：
列表(list)推导式
字典(dict)推导式
集合(set)推导式
元组(tuple)推导式
2.1 列表推导式
1.列表推导式格式为：
[表达式 for 变量 in 列表]
[out_exp_res for out_exp in input_list]
或者
[表达式 for 变量 in 列表 if 条件]
[out_exp_res for out_exp in input_list if condition]
或
[表达式 for 变量 in 序列]
让变量去序列中取值，每取一个值就创建列表中的一个元素，元素的值就是表达式的值
for 变量 in 序列：
产生元素
#out_exp_res：列表生成元素表达式，可以是有返回值的函数。
#for out_exp in input_list：迭代 input_list 将 out_exp 传入到 out_exp_res 表达式中。
#if condition：条件语句，可以过滤列表中不符合条件的值。
`例子`
list1 = [2*x for x in range(4)] #表达式:2*x的值,x的值为输出0-3的数值和2相乘
print(list1) #打印结果
结果:[0, 2, 4, 6] #2*0,2*1,2*2,2*3
# coding = utf-8
names = ['****','lwx','xhs','alice','tony'] #定义一个列表
name = [name.upper() for name in names if len(name)>3]
##新的name等于,name.upper:传入的值大写,变量为name,循环条件为names(出现的数量),如果传入的name的字符串长度大于三才会匹配
print(name)
计算 30 以内可以被 3 整除的整数：
# coding = utf-8
multiples = [i for i in range(30) if i % 2 != 0 ] #定义i为1-30的值,如果i不能够整除2,则满足条件
print(multiples)
结果:[1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29]
2.2 字典推导式
1.字典推导基本格式：
{ key_expr: value_expr for value in collection }
或
{ key_expr: value_expr for value in collection if condition }
`案例1`
使用字符串及其长度创建字典：
# coding = utf-8
listdict = ['Google','Taobao','JD']
#定义列表为后面的内容
newdict = {key:len(key) for key in listdict if len(key) >= 2}
#字典为,表达式键:键的长度,key为获取listdict中定义的内容(3次),如果获取到的key长度大于等于2,则满足条件
print(newdict)
#{'Google': 6, 'Taobao': 6, 'JD': 2}
`案例2`
提供三个数字，以三个数字为键，三个数字的平方为值来创建字典：
# coding = utf-8
dic = {x:x**2 for x in (2,4,6) if x < 5}
#变量dic,表达式为x:x的俩次方,x为2、4、6,如果x小于5则满足条件
print(dic,type(dic))
#{2: 4, 4: 16} <class 'dict'>
`案例3`
#coding utf-8
#author "*****"
name = ['****','lwx','xhs','alice','toml'] #定义列表
names = {i:i*1+'hh' for i in name if len(i) > 3} #字典为
print(names.keys()) ##输出所有键
print(names.values()) #输出所有值
print(names['alice']) #输出键为alice的值
结果:
dict_keys(['alice', 'toml'])
dict_values(['alicehh', 'tomlhh'])
alicehh
2.3 集合推导式
集合推导式基本格式：
{ expression(表达式) for item(项目) in Sequence(序列) }
或
{ expression for item in Sequence if conditional }
`案例`
# coding = utf-8
set = {i**2 for i in range(1,10) if i < 5 } #列表为i的二次方,i为1-10,i<5则满足条件
print(set)
`结果`
{16, 1, 4, 9} --因为条件为i<5则只有0-4会进行计算输出
`案例2`
#判断不是 abc 的字母并输出：
a = {x for x in 'abcdefghijklmn' if x not in 'abcd,hijk'}
print(a)
2.4 元组推导式（生成器表达式）
元组推导式可以利用 range 区间、元组、列表、字典和集合等数据类型，快速生成一个满足指定需求的元组。
元组推导式基本格式：
(expression(表达式) for item(项目) in Sequence(序列) )
或
(expression for item in Sequence if conditional(条件) )
`案例`
# coding = utf-8
#代码生成一个包含数字 1~9 的元组：
a = (x for x in range(1,10) if x >= 1)
print(a)
print(tuple(a)) #将生成器对象进行转换
结果:
<generator object <genexpr> at 0x0000025F1BCB06D8> #默认返回的是生成器对象
(1, 2, 3, 4, 5, 6, 7, 8, 9)
3.解释器
3.1linux安装py环境
1.ubuntu
env:PRETTY_NAME="Ubuntu 20.04.5 LTS"
--安装依赖包
root@ubuntu:~/python# sudo apt install -y build-essential zlib1g-dev libncurses5-dev libgdbm-dev libnss3-dev libssl-dev libsqlite3-dev libreadline-dev libffi-dev curl libbz2-dev
--下载对应的python包
#进入python.org->找到linux进行下载 || wget https://www.python.org/ftp/python/3.11.1/Python-3.11.1.tgz
--安装python
root@ubuntu:~/python/software# tar -xvf Python-3.11.1.tgz
root@ubuntu:~/python/software/Python-3.11.1# ./configure --enable-optimizations
root@ubuntu:~/python/software/Python-3.11.1# make && sudo make install
root@ubuntu:~# rm -rf /usr/bin/python3 --删除原有的python
root@ubuntu:~/python/software/Python-3.11.1# sudo ln -s /usr/local/bin/python3.11 /usr/bin/python
root@ubuntu:~/python/software/Python-3.11.1# python --version
Python 3.11.1 --完成
------------------------------------------------------------------------------------------------------------
2.centos
env:CentOS Linux release 7.9.2009 (Core)
--安装依赖包
[root@python ~]# yum install wget zlib-devel bzip2-devel openssl-devel ncurses-devel sqlite-devel readline-devel tk-devel gcc make zlib zlib-devel libffi-devel -y
--下载对应的python包
#进入python.org->找到linux进行下载 || wget https://www.python.org/ftp/python/3.11.1/Python-3.11.1.tgz
--安装python包
[root@python python]# tar -xvf Python-3.11.1.tgz
[root@python Python-3.11.1]# ./configure --prefix=/usr/local/python3.11
[root@python Python-3.11.1]# make && make install
[root@python bin]# pwd
/usr/local/python3.11/bin --进入编译后的目录
[root@python bin]# ./python3 --version --查看版本是否正确
Python 3.11.1
[root@python bin]# ./python3 --能否进入python终端
[root@python bin]# ln -s /usr/local/python3.11/bin/python3.11 /usr/bin/python --做个软连接,如果提示存在删了就行
[root@python bin]# python
Python 3.11.1 (main, Dec 15 2022, 05:04:41) [GCC 4.8.5 20150623 (Red Hat 4.8.5-44)] on linux
Type "help", "copyright", "credits" or "license" for more information.
#大功告成
--修复yum
linux系统中yum程序默认使用python2版本，
[root@python bin]# vi /usr/libexec/urlgrabber-ext-down --改成python2
[root@python bin]# vi /usr/bin/yum --同上即可
[root@python bin]# python --version
Python 3.11.1 --OK
4.运算符
4.1 算术运算符
1.用法
+ 加 - 两个对象相加 a + b 输出结果 31
- 减 - 得到负数或是一个数减去另一个数 a - b 输出结果 -11
* 乘 - 两个数相乘或是返回一个被重复若干次的字符串 a * b 输出结果 210
/ 除 - x 除以 y b / a 输出结果 2.1
% 取模 - 返回除法的余数 b % a 输出结果 1
** 幂 - 返回x的y次幂 a**b 为10的21次方
// 取整除 - 向下取接近商的整数 >>> 9//2 4 >>> -9//2 -5
2.案例
# coding = utf-8
a = 21
b = 10
c = 0
print(a+b+c) --31
print(a-b-c) --11
print(a*b-c) --210
print(a/b+c) --2.1
print(a%b) --1(返回余数)--21除10结果为2(不返回)余数为1
a = 2 #值可以被重新定义
b = 3
c = a**b
print('c的值为:',c) --8(2的3次方)
a = 12
b = 5
c = a//b
print('c的值为:',c) --2(取整除数字)
4.2 比较运算符
1.语法
以下假设变量a为10，变量b为20:
== 等于 - 比较对象是否相等 (a == b) 返回 False。
!= 不等于 - 比较两个对象是否不相等 (a != b) 返回 True。
> 大于 - 返回x是否大于y (a > b) 返回 False。
< 小于 - 返回x是否小于y.所有比较运算符返回1表示真,返回0表示假.这分别与特殊的变量True和False等价.注意,这些变量名的大写
>= 大于等于 - 返回x是否大于等于y。 (a >= b) 返回 False。
<= 小于等于 - 返回x是否小于等于y。 (a <= b) 返回 True。(尽量少用,<就会返回true)
2.案例
# coding = utf-8
a = 10
import time #导入时间模块
b = int(input("输入数字b:")) #设置b为交互式获取数据
if True: #如果b设置且输入的内容为整形,则进行判断
print("开始计算")
time.sleep(1) #sleep1秒钟
if (a==b): #如果a==b打印内容并推出
print('a == b')
exit(0)
elif (a < b):
print('a < b')
exit(0)
else:
print('a > b','a != b')
exit(1)
4.3 赋值运算符
1.以下假设变量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
:= 海象运算符，可在表达式内部为变量赋值。Python3.8 版本新增运算符。
在这个示例中，赋值表达式可以避免调用 len() 两次:
if (n := len(a)) > 10:
print(f"List is too long ({n} elements, expected <= 10)")
2.案例
# coding = utf-8
a = 2
b = 3
c = a+b #定义c的值:
print(c) --5
c += a #c = c+a
print(c) #c为7,值会跟着上一次计算的值赋值
c -= a
print(c) --5
c *= a
print(c) --10
c = c / a
print(c) --5.0
c //= a
print(c) --2.0
c **= a
print(c) --4
c %= a
print(c) --0(可以整除返回0)
4.4 位运算符
1.按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如下：
下表中变量 a 为 60，b 为 13二进制格式如下：
& 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 (a & b) 输出结果 12 ，二进制解释： 0000 1100
| 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 (a | b) 输出结果 61 ，二进制解释： 0011 11001
^ 按位异或运算符：当两对应的二进位相异时，结果为1 (a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~ 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1。~x 类似于 -x-1 (~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。
<< 左移动运算符：运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 a << 2 输出结果 240 ，二进制解释： 1111 0000
>> 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数 a >> 2 输出结果 15 ，二进制解释： 0000 1111
`案例`
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
#根据数值的二进制进行运算
c = a & b # 12 = 0000 1100
print("1 - c 的值为：", c) --12
c = a | b # 61 = 0011 1101
print("2 - c 的值为：", c) --61
c = a ^ b # 49 = 0011 0001
print("3 - c 的值为：", c) --49
c = ~a # -61 = 1100 0011
print("4 - c 的值为：", c) --(-61)
c = a << 2 # 240 = 1111 0000
print("5 - c 的值为：", c) --240
c = a >> 2 # 15 = 0000 1111
print("6 - c 的值为：", c) --15
4.5 逻辑运算符
1.Python语言支持逻辑运算符，以下假设变量 a 为 10, b为 20:
and x and y 布尔"与" - 如果 x 为 False，x and y 返回 x 的值，否则返回 y 的计算值。 (a and b) 返回 20。
or x or y 布尔"或" - 如果 x 是 True，它返回 x 的值，否则它返回 y 的计算值。 (a or b) 返回 10。
not not x 布尔"非" - 如果 x 为 True，返回 False.如果x为False,它返回-True not(a and b) 返回 False
2.`案例`
a = 123
b = 345
if (a > 10 and b > 10 ): #a>10并且b>10才会返回yes
print("yes")
else:
print("no")
a = 9;b = 10
if ( a > 10 or b == 10): #满足其一返回true
print("true")
else:
print("false")
if (a != 8 ): #不等于返回true
print("true")
else:
print("false")
#() >not >and >or
4.6 成员运算符
除了以上的一些运算符之外，Python还支持成员运算符，测试实例中包含了一系列的成员，包括字符串，列表或元组。
运算符 描述 实例
in 如果在指定的序列中找到值返回 True，否则返回 False。 x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in 如果在指定的序列中没有找到值返回 True，否则返回 False。 x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。
`案例`
#coding utf-8
import time
a = 10
b = 20
list = [1,2,3,4,5]
if a in list:
print(list[a])
else:
print(f"{a} is not in list")
time.sleep(0.5)
print('but')
new_list = [10,22,33,44,55,66,77,88,99]
if a not in new_list:
print(f'{a} is not in new_list')
else:
print(f'{a} is in new_list')
4.7 身份运算符
身份运算符用于比较两个对象的存储单元
运算符 描述 实例
is is 是判断两个标识符是不是引用自一个对象 x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False
is not is not 是判断两个标识符是不是引用自不同对象 x is not y ， 类似 id(x) != id(y)。如果引用的不是同一个对象则返回结果 True，否则返回 False。
`案例`
#coding utf-8
a = 20
b = 20
if (a is b):
print("a == b")
else:
print("a != b")
a = "haha"
b = "nono"
if (a is not b):
print("a != b")
else:
print("a == b")
is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个， == 用于判断引用变量的值是否相等。
`案例`
#coding uth-8
a = [1,2,3,4]
b = a
if (a is b): --此处判断是a是否和b都引用了同一个元素[1,2,3,4]
print("true") --所以此处返回结果为true
else:
print(f"false b is{b}")
b = a[0:2] --b为0-2的列表内容
print(a[0:2])
if (a == b): --==判断元素值是否相同
print("true")
else:
print("false") --此处返回false
4.8 运算符优先级
`案例`
#coding uth-8
a = 20
b = 10
c = 5
d = 2
e = ( a + b ) * c / d #先算括号里面的
print(e) --75.0
e = a + ( b * c ) - d
print(e)
#coding uth-8
x = 'true'
y = 'false'
z = 'false'
if x or y and z: #or二者布尔值1个正确则为true,and俩这都为真返回true
print("yes")
else:
print("false")
#以上实例先计算 y and z 并返回 False ，然后 x or y 返回 True，输出结果：
#以下表格列出了从最高到最低优先级的所有运算符， 相同单元格内的运算符具有相同优先级。 运算符均指二元运算，除非特别指出。 相同单元格内的运算符从左至右分组（除了幂运算是从右至左分组）：
| 运算符 |
描述 |
(expressions...),[expressions...], {key: value...}, {expressions...}
|
圆括号的表达式 |
x[index], x[index:index], x(arguments...), x.attribute
|
读取，切片，调用，属性引用 |
| await x |
await 表达式 |
** |
乘方(指数) |
+x, -x, ~x
|
正，负，按位非 NOT |
*, @, /, //, %
|
乘，矩阵乘，除，整除，取余 |
+, -
|
加和减 |
<<, >>
|
移位 |
& |
按位与 AND |
^ |
按位异或 XOR |
| ` |
` |
in,not in, is,is not, <, <=, >, >=, !=, == |
比较运算，包括成员检测和标识号检测 |
not x |
逻辑非 NOT |
and |
逻辑与 AND |
or |
逻辑或 OR |
if -- else |
条件表达式 |
lambda |
lambda 表达式 |
:= |
赋值表达式 |
5.数据类型的学习
5.1 数字(Number)
1.Python 支持三种不同的数值类型：
整型(int) - 通常被称为是整型或整数，是正或负整数，不带小数点。Python3 整型是没有限制大小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。布尔(bool)是整型的子类型。
浮点型(float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 = 2.5 x 102 = 250）
复数( (complex)) - 复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
--我们可以使用十六进制和八进制来代表整数：
#coding uth-8
number = 0xA0F
print(number) --2575
number = 0o37
print(number) --31
Python支持复数，复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示， 复数的实部a和虚部b都是浮点型。
| int |
float |
complex |
| 10 |
0.0 |
3.14j |
| 100 |
15.20 |
45.j |
| -786 |
-21.9 |
9.322e-36j |
| 080 |
32.3e+18 |
.876j |
| -0490 |
-90. |
-.6545+0J |
| -0x260 |
-32.54e100 |
3e+26J |
| 0x69 |
70.2E-12 |
4.53e-7j |
5.2 数学函数
abs(x) 返回数字的绝对值，如abs(-10) 返回 10
ceil(x) 返回数字的上入整数，如math.ceil(4.1) 返回 5
exp(x) 返回e的x次幂(ex),如math.exp(1) 返回2.718281828459045
fabs(x) 返回数字的绝对值，如math.fabs(-10) 返回10.0
floor(x)返回数字的下舍整数，如math.floor(4.9) 返回4
log(x) 如math.log(math.e)返回1.0,math.log(100,10) 返回2.0
log10(x)返回以10为基数的x的对数，如math.log10(100) 返回2.0
max(x1, x2,...) 返回给定参数的最大值，参数可以为序列。 返回最大的变量值
min(x1, x2,...) 返回给定参数的最小值，参数可以为序列。 返回最小变量值
pow(x, y) x**y 运算后的值。
round(x) 返回浮点数 x 的四舍五入值，如给出n值，则代表舍入到小数点后的位数。
sqrt(x) 返回数字x的平方根。
`案例`
a=11.2
print(math.ceil(a))
5.3 随机数函数
choice(seq) 从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
#
randrange ([start,] stop [,step]) 从指定范围内，按指定基数递增的集合中获取一个随机数，基数默认值为 1
#
random() 随机生成下一个实数，它在[0,1)范围内。
#print(random.random())
seed([x]) 改变随机数生成器的种子seed。如果你不了解其原理，你不必特别去设定seed，Python会帮你选择seed。
#
shuffle(lst) 将序列的所有元素随机排序
#
uniform(x, y) 随机生成下一个实数，它在[x,y]范围内。
#print(random.uniform(1,2))
#以上都基于random的子元素进行计算输出调用
-----使用手册
`choice(seq)` **
#从序列的元素中随机挑选一个元素，比如random.choice(range(10))，从0到9中随机挑选一个整数。
--案例
import random
print ("从 range(100) 返回一个随机数 : ",random.choice(range(100)))
print ("从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : ", random.choice([1, 2, 3, 5, 9]))
print ("从字符串中 'Runoob' 返回一个随机字符 : ", random.choice('Runoob'))
--结果
从 range(100) 返回一个随机数 : 84
从列表中 [1, 2, 3, 5, 9]) 返回一个随机元素 : 1
从字符串中 'Runoob' 返回一个随机字符 : u
`randrange()` **
# 方法返回指定递增基数集合中的一个随机数，基数默认值为1。
--案例
#coding utf-8
#author "*****"
import random
# 从 1-6 中选取一个奇数
print("randrange(1,6,2):",random.randrange(1,6,2)) --范围为1-6指定递增的步伐为2,及结果为1+2或者(1+2)+2以此类推最大为6
# 从 0-99 选取一个随机数
print ("randrange(100) : ", random.randrange(100))
--结果
randrange(1,6,2): 5
randrange(100) : 10
--randrange(0,100, 2) # 从0-100中随机选取一个偶数 --0+2每隔2进行计算。结果肯定为偶数
--randrange(0,100, 4) # 从0-100中随机选取一个能被4整除的整数 --0+4依次加4的值.所以肯定可以整除4
--randrange(1,100, 3) # 从0-100中随机选取一个能被3整除后余1的数 --1+3依次加3所以值为除三余1
`random`
#random() 方法返回随机生成的一个实数，它在半开放区间 [0,1) 范围内
#半开区间、开区间、闭区间
(a,b] --半开区间包含b不包含a ==a < x <= b
(a,b) --开区间不包含a和b的值 ==a < x < b
[a,b] --闭区间包含a和b的值 ==a<= x <= b
--案例
#coding utf-8
#author "*****"
import random
# 第一个随机数
print ("random() : ", random.random()) --只能生成包含0-1内的float数字
# 第二个随机数
print ("random() : ", random.random())
--结果
random() : 0.27844640535608645
random() : 0.7631633645522709
`seed`
#seed() 方法改变随机数生成器的种子，可以在调用其他随机模块函数之前调用此函数
##我们调用 random.random() 生成随机数时，每一次生成的数都是随机的。但是，当我们预先使用 random.seed(x) 设定好种子之后，其中的 x 可以是任意数字，如10，这个时候，先调用它的情况下，使用 random() 生成的随机数将会是同一个。
--案例
#coding utf-8
#author "*****"
import random
random.seed(10)
print("种子数字为10,生成随机数: ",random.random()) --声明种子数字seed后,[0,1)的随机数为一致的
random.seed(10)
print("种子数字为10,生成随机数: ",random.random()) --声明种子数字seed后,[0,1)的随机数为一致的
random.seed()
print("种子数字为空,生成随机数: ",random.random()) --声明随机的seed后,random不一致
--结果
种子数字为10,生成随机数: 0.5714025946899135
种子数字为10,生成随机数: 0.5714025946899135
种子数字为空,生成随机数: 0.5373277903654347
`shuffle`
#shuffle() 方法将序列的所有元素随机排序。
--案例
#coding utf-8
#author "*****"
import random --导入随机数模块
list = [1,2,3,4] --定义列表
random.shuffle(list) --通过shuffle随机数函数将list进行处理
print("随机列表为:",list) --返回处理后的数据
--结果
随机列表为: [2, 3, 1, 4]
`uniform`
#uniform()方法将随机生成下一个实数，它在 [x,y] 范围内。
#返回一个浮点数 N，取值范围为如果 x<y 则 x <= N <= y，如果 y<x 则y <= N <= x。
--案例
#coding utf-8
#author "*****"
import random
print("uniform(5,10) 随机浮点数为:",random.uniform(5,10)) --生成5-10的随机浮点数
print("uniform(11,20,2)随机浮点数为:",round(random.uniform(11,20),2)) --生成随机浮点数精确到小数点后俩位
--结果
uniform(5,10) 随机浮点数为: 6.7631951466591245
uniform(11,20,2)随机浮点数为: 15.23
5.4 三角函数
Python包括以下三角函数：
函数 描述
acos(x) 返回x的反余弦弧度值。
asin(x) 返回x的反正弦弧度值。
atan(x) 返回x的反正切弧度值。
atan2(y, x) 返回给定的 X 及 Y 坐标值的反正切值。
cos(x) 返回x的弧度的余弦值。
hypot(x, y) 返回欧几里德范数 sqrt(x*x + y*y)。
sin(x) 返回的x弧度的正弦值。
tan(x) 返回x弧度的正切值。
degrees(x) 将弧度转换为角度,如degrees(math.pi/2) ， 返回90.0
radians(x) 将角度转换为弧度
数字常量
常量 描述
pi 数学常量 pi（圆周率，一般以π来表示）
e 数学常量 e，e即自然常数（自然常数）。
6.字符串
6.1 转义字符
| 转义字符 |
描述 |
实例 |
| (在行尾时) |
续行符 |
>>> print(“line1 \ … line2 \ … line3”) line1 line2 line3` |
| \ |
反斜杠符号 |
>>> print("\\") |
| ’ |
单引号 |
>>> print('\'') |
| " |
双引号 |
>>> print("\"") |
| \a |
响铃 |
>>> print("\a")执行后电脑有响声。 |
| \b |
退格(Backspace) |
>>> print("Hello \b World!") result:Hello World! |
| \000 |
空 |
>>> print("\000") 输出空 |
| \n |
换行 |
>>> print("\n") |
| \v |
纵向制表符 |
>>> print(“Hello \v World!”) Hello World! |
| \t |
横向制表符 |
>>> print("Hello \t World!") |
| \r |
回车，将 \r 后面的内容移到字符串开头，并逐一替换开头部分的字符，直至将 \r 后面的内容完全替换完成。 |
>>> print(“Hello\rWorld!”) World! |
| \f |
换页 |
|
| \yyy |
八进制数，y 代表 0~7 的字符，例如：\012 代表换行。 |
|
| \xyy |
十六进制数，以 \x 开头，y 代表的字符，例如：\x0a 代表换行 |
|
| \other |
其它的字符以普通格式输出 |
|
6.2 字符串运算符
操作符 描述 实例
#下表实例变量 a 值为字符串 "Hello"，b 变量值为 "Python"：
+ 字符串连接 a + b 输出结果： HelloPython
* 重复输出字符串 a*2 输出结果：HelloHello
[] 通过索引获取字符串中字符 a[1] 输出结果 e
[ : ] 截取字符串中的一部分，遵循左闭右开原则(末位不要)，str[0:2] 是不包含第3个字符的。a[1:4]输出结果ell
in 成员运算符 - 如果字符串中包含给定的字符返回 True 'H' in a 输出结果 True --H在a(Hello)中
not in 成员运算符 - 如果字符串中不包含给定的字符返回 True 'M' not in a 输出结果 True --M不在a(Hello)中
r/R 原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。 原始字符串除在字符串的第一个引号前加上字母 r（可以大小写）以外，与普通字符串有着几乎完全相同的语法。
print( r'\n' ) print( R'\n' )
% 格式字符串
6.3 字符串格式化
#Python 支持格式化字符串的输出 。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将一个值插入到一个有字符串格式符 %s 的字符串中。
1.在Python中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
符 号 描述
%c 格式化字符及其ASCII码
%s 格式化字符串
%d 格式化整数
%u 格式化无符号整型
%o 格式化无符号八进制数
%x 格式化无符号十六进制数
%X 格式化无符号十六进制数（大写）
%f 格式化浮点数字，可指定小数点后的精度
%e 用科学计数法格式化浮点数
%E 作用同%e，用科学计数法格式化浮点数
%g %f和%e的简写
%G %f 和 %E 的简写
%p 用十六进制数格式化变量的地址
`案例`
print("我叫%s,今年%d岁!" % ("小明",10)) #%s会去找%后定义的字符串内容,d会去找int
格式化操作符辅助指令:
符号 功能
* 定义宽度或者小数点精度
- 用做左对齐
+ 在正数前面显示加号( + )
<sp> 在正数前面显示空格
# 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0 显示的数字前面填充'0'而不是默认的空格
% '%%'输出一个单一的'%'
(var) 映射变量(字典参数)
m.n. m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)
Python2.6 开始，新增了一种格式化字符串的函数 str.format()，它增强了字符串格式化的功能。
6.4 python三引号
1.para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
#类似shell中的EOF
2.f-string
#f-string 是 python3.6 之后版本添加的，称之为字面量格式化字符串，是新的格式化字符串的语法
#%格式化字符串(调用变量信息)
name = 'randon'
print(f'hello {name}') == print('hello %s' % name )
x = 1
print(f'{x+1=}')
#用了这种方式明显更简单了，不用再去判断使用 %s，还是 %d。
`Unicode 字符串`
在Python2中，普通字符串是以8位ASCII码进行存储的，而Unicode字符串则存储为16位unicode字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在Python3中，所有的字符串都是Unicode字符串。
6.5 字符串内建函数
1 capitalize()
#将字符串的第一个字符转换为大写其他字母变小写。
`案例`
#coding utf-8
#author ****
>>hh = "this is new string study"
>>print(f"将hh中的str进行转换:{hh}",f"修改为:{hh.capitalize()}")
==将hh中的str进行转换:this is new string study 修改为:This is new string study
>>> str="123 hello PYTHON"
>>> str.capitalize()
'123 hello python' --str中开头第一个字符不为大写字符不会发生变化.所有字符替换为小写
需要注意的是：
@1=首字符会转换成大写，其余字符会转换成小写。
@2=首字符如果是非字母，首字母不会转换成大写，会转换成小写。
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+------
2 center(width, fillchar)
#返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。
center()方法语法：
str.center(width[, fillchar])
`案例`
>>>str = 'runbo' --指定字符串
>>>print("str.center(20,'*')",str.center(20,'*'),len(str.center(20,'*'))) --指定字符串的总长度为20字符,用*进行填充
>>>print(len(str.center(20,'*')))
str.center(20,'*') --**runbo--*** 20 --可以看到runbo+*一共有20个字符
##注意##
--如果width(宽度)小于字符串宽度直接返回字符串，不会截断:
@1=print('123'.center(4, '*')) # 奇数个字符时优先向右边补*
# 123*
@2=print('1234'.center(5, '*')) # 偶数个字符时优先向左边补*
# *1234
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+------
3 count(str, beg= 0,end=len(string))
#返回 str 在 string 里面出现的次数，如果 beg或者end指定则返回指定范围内 str 出现的次数
count()方法语法：
str.count(sub, start= 0,end=len(string))
`参数`
sub -- 搜索的子字符串
start -- 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end -- 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。
`案例`
>>>str = 'www.coo123.com'
>>>sub = "o" --定义要查询的字符
>>>print("str.count('o')",str.count(f"{sub}",0,-1)) --查询str中o出现的次数,索引为全部字符
str.count('o') 3 --全文字符中出现了3次
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
4 bytes.decode(encoding="utf-8", errors="strict"){
#Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
#decode() 方法以指定的编码格式解码 bytes 对象。默认编码为 'utf-8'。
语法
decode()方法语法：
bytes.decode(encoding="utf-8", errors="strict")
参数
encoding -- 要使用的编码，如"UTF-8"。
errors -- 设置不同错误的处理方案。默认为 'strict',意为编码错误引起一个UnicodeError。 其他可能得值有 'ignore', 'replace', 'xmlcharrefreplace', 'backslashreplace' 以及通过 codecs.register_error() 注册的任何值。
}
`案例`
>>str = '学习之路'
>>str_utf8 = str.encode("utf-8") --给str进行编码,类型为utf-8
>>del str --删除str的定义
>>str = '我爱python' --重新定义str的内容
>>str_gbk = str.encode("GBK") --给str进行编码,类型为GBK
>>print("UTF-8编码:",str_utf8);print("GBK编码",str_gbk) --打印出utf-8编码后的内容以及GBK的编码内容
##解码
>>print("utf-8解码:",str_utf8.decode('utf-8','strict')) --打印出解码的内容
>>print("GBK解码:",str_gbk.decode('GBK','strict'))
UTF-8编码: b'\xe5\xad\xa6\xe4\xb9\xa0\xe4\xb9\x8b\xe8\xb7\xaf'
GBK编码 b'\xce\xd2\xb0\xaepython'
utf-8解码: 学习之路
GBK解码: 我爱python
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
5 encode(encoding='UTF-8',errors='strict')
#以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
#同上decode
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
6 endswith(suffix, beg=0, end=len(string))
#检查字符串是否以 suffix(后缀) 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 suffix 结束，如果是，返回 True,否则返回 False。
endswith()方法语法：
str.endswith(suffix[, start[, end]])
参数
suffix -- 该参数可以是一个字符串或者是一个元素。
start -- 字符串中的开始位置。
end -- 字符中结束位置。
`案例`
>>str = '**** is good boy!!!'
>>print(str.endswith('!',0,-1)) --查看str中0--1的索引内容及全部内容是否以!进行结尾.会遵循左闭右开原则
>>del str
>>str = '**** is not good boy@@'
>>suffix = '@'
>>print(str.endswith(suffix,0,-4)) --查看str中0--4索引内容是否结尾为@,明显结果为false
--结果
True
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
7 expandtabs(tabsize=8)
#把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
expandtabs() 方法语法：
#expandtabs() 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16...等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。
#字符串+\t一共为8个字符.不足8个以空格替代
str.expandtabs(tabsize=8)
参数
tabsize -- 指定转换字符串中的 tab 符号 \t 转为空格的字符数.
`案例`
>>str = 'runnbo\t12345\t123'
>>print(str)
##runnbo有6个字符到\t为2个字符,12345为5个字符-\t为3个字符
>>print(str.expandtabs()) ##不指定为字符到\t共8个字符,不足用空格表示
>>print(str.expandtabs(10),len(str.expandtabs(10))) ##指定字符到\t共10个字符
##runnbo为6个字符到\t差4个及补4个空格.12345到\t补5个字符。至此共20个+123为23个字符
--结果
runnbo 12345 123
runnbo 12345 123
runnbo 12345 123 23
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
8 find(str, beg=0, end=len(string))
#检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
find()方法语法：
str.find(str, beg=0, end=len(string))
参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
`案例`
>>info = 'abcda'
>>print(info.find('a',1)) --查询字符串中是否包含a,从下标1开始及索引1开始.
>>print(info.find('e'),info.find('c')) --查询是否包含e,和c
--结果
4 --索引4时发现a
-1 2 ---1为未发现,索引2发现c
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
9 index(str, beg=0, end=len(string))
#跟find()方法一样，只不过如果str不在字符串中会报一个异常。
index()方法语法：
str.index(str, beg=0, end=len(string))
参数
str -- 指定检索的字符串
beg -- 开始索引，默认为0。
end -- 结束索引，默认为字符串的长度。
`案例`
>>info = 'this is find index usege'
>>str1 = 'index'
>>print(info.index(str1))
>>print(info.index('useage',0,-1))
--结果
13
ValueError: substring not found --没有会报错误
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
10 isalnum()
#如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False
isalnum()方法语法：
str.isalnum()
`案例`
>>info = 'this is find index usege'
>>print(info.isalnum()) --字符串中有特殊符号则为false
>>del info
>>info = 'asdsda123' --字符串中没有特殊符号则为true
>>print(info.isalnum())
--结果
False
True
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
11 isalpha()
#如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
isalpha()方法语法：
str.isalpha()
`案例`
>>str = 'rundo'
>>print(str.isalpha())
>>del str
>>str = '123haha..'
>>print(str.isalpha())
--结果
True --必须变量内容中只包含字符串才会返回true
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
12 isdigit()
#如果字符串只包含数字则返回 True 否则返回 False..
`案例`
>>num1 = '123'
>>print(num1.isdigit())
>>num2 = 'ashdhasd'
>>print(num2.isdigit())
--结果
True
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
13 islower()
#如果字符串中包含至少一个区分大小写的字符,并且所有这些(区分大小写的)字符都是小写,则返回True,否则返回False
`案例`
>>str1 = 'HH123hh'
>>print(str1.islower())
>>str2 = 'hhsadhh123'
>>print(str2.islower())
--结果
False
True
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
14 isnumeric()
#如果字符串中只包含数字字符，则返回 True，否则返回 False
`案例`
>>num1 = '123456'
>>print(num1.isnumeric())
>>num2 = 'hh123'
>>print(num2.isnumeric())
--结果
True
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
15 isspace()
#如果字符串中只包含空白，则返回 True，否则返回 False.
`案例`
>>str1 = ' '
>>print(str1.isspace())
>>str1 = '123hh..'
>>print(str1.isspace())
--结果
True --变量内容只有空格的时候才会是true
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
16 istitle()
#方法检测字符串中所有的单词拼写首字母是否为大写，且其他字母为小写。
`案例`
>>str1 = 'This Is Ha 123..##'
>>print(str1.istitle())
>>str1 = 'this is h '
>>print(str1.istitle())
--结果
True --字符串中单个单词的开头必须为大写才会返回true
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
17 isupper()
#检测字符串中所有的字母是否都为大写。
`案例`
>>str1 = 'HELLOWORD%^&*I123213..'
>>print(str1.isupper())
>>str1 = 'this is h '
>>print(str1.isupper())
--结果
True
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
18 join(seq)
#以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
#用于将序列中的元素以指定的字符连接生成一个新的字符串。
>>s1 = ""
>>s2 = ".."
>>str_list = ('1','n','s','3')
>>print(s1.join(str_list))
>>print(s2.join(str_list))
--结果
1ns3
1..n..s..3
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
19 len(string)
#返回字符串长度
`案例`
>>s1 = 'hahhaha'
>>print(len(s1),s1)
--结果
7
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
20 ljust(width[, fillchar])
#返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
ljust()方法语法：
str.ljust(width[, fillchar])
参数：
width -- 指定字符串长度。
fillchar -- 填充字符，默认为空格。
`案例`
>>str = 'love is fuck moving'
>>print(str.ljust(25,'*')) --25为字符总长,不足的用*号代替.类似center
--结果
love is fuck moving--*
#返回一个原字符串左对齐,并使用空格填充至指定长度的新字符串。如果指定的长度小于原字符串的长度则返回原字符串。
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
21 lower()
#转换字符串中所有大写字符为小写.
`案例`
>>str = 'love is FUck MOVING'
>>print(str.lower())
--结果
love is fuck moving
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
22 lstrip()
#截掉字符串左边的空格或指定字符。
`案例`
>>str = '##### love is FUck MOVING'
>>newstr = (str.lstrip('#')) --删除左边字符包含#的内容
>>print(newstr.lstrip()) --删除左侧包含空格的内容
--结果
love is FUck MOVING
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
23 maketrans()
#创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
maketrans()方法语法：
string.maketrans(x[, y[, z]])
参数
x -- 必需，字符串中要替代的字符组成的字符串。
y -- 可选，相应的映射字符的字符串。
z -- 可选，要删除的字符。
`案例`
>>txt = "Google Runoob Taobao!"
>>x = "Glgu" --要替换的内容
>>y = "1234" --替换后的内容
>>z = "o!" # 设置删除的字符
>>mytable = txt.maketrans(x, y, z) --设定要映射的表格
>>print(txt.translate(mytable)) --translate根据给出的表格进行字符串的转换
--结果
132e R4nb Taba
#两个参数 x 和 y，x、y 必须是长度相等的字符串，并且 x 中每个字符映射到 y 中相同位置的字符
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
24 max(str)
#返回字符串 str 中最大的字母。
`案例`
>>str = 'abcdzx'
>>print(max(str),min(str))
--结果
z a
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
25 min(str)
#返回字符串 str 中最小的字母。
`案例`
>>str = 'abcdzx'
>>print(max(str),min(str))
--结果
z a
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
26 replace(translateold, new [, max])
#把将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
`案例`
>>str = 'www.qqkj.com'
>>print("强强科技新地址:",str.replace("qqkj","gok"))
>>new_str = 'www.www.www.www'
>>print(new_str.replace("www","hh",3)) --替换字符中的www为hh最多替换三次
--结果
强强科技新地址: www.gok.com
hh.hh.hh.www
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
27 rfind(str, beg=0,end=len(string))
#类似于 find()函数，不过是从右边开始查找.
`案例`
>>str = 'www.qqkj.com'
>>print(str.rfind('m'))
--结果
11 --11的索引位为m,没找到是notfound
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
28 rindex( str, beg=0, end=len(string))
#类似于 index()，不过是从右边开始.
`案例`
>>str = 'www.qqkj.com'
>>print(str.rindex('m'),str.rfind('hhh'))
--结果
11 -1 --(-1)为未找到,字符串中不包含hhh
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
29 rjust(width,[, fillchar])
#返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
`案例`
>>str = ' www.qqkj.com'
>>print(str.rjust(15,'*'))
--结果
** www.qqkj.com --从右往左数15个字符不够则用*代替
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
30 rstrip()
#删除字符串末尾的空格或指定字符。
`案例`
>>str = ' www.qqkj.com**'
>>print(str.rstrip("**")+str.strip())
--结果
www.qqkj.comwww.qqkj.com** --右对齐删除**,左对齐删除空格
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
31 split(str="", num=string.count(str))
#str为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
split() 方法语法：
str.split(str="", num=string.count(str))
参数
str -- 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num -- 分割次数。默认为 -1, 即分隔所有。
`案例`
>>url = "http://www.baidu.com/python/image/123456.jpg"
>>print(url.split("/"));print(url.split("/")[-1]) --输出以/号分隔的内容,不指定次数,遇到就分隔.输出-1索引值
>>print(url.split("/",2)) --以/进行分隔,分隔俩次
--结果
['http:', '', 'www.baidu.com', 'python', 'image', '123456.jpg']
123456.jpg
['http:', '', 'www.baidu.com/python/image/123456.jpg']
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
32 splitlines([keepends])
#按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
splitlines()方法语法：
str.splitlines([keepends])
#keepends -- 在输出结果里是否去掉换行符('\r', '\r\n', \n')，默认为 False，不包含换行符，如果为 True，则保留换行符。
`案例`
>>str = '1234\n12321\n123\r'
>>print(str.splitlines()) --默认false,输出不带换行符,以换行符进行分隔
>>print(str.splitlines(True)) --true输出后的内容携带换行符
--结果
['1234', '12321', '123']
['1234\n', '12321\n', '123\r']
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
33 startswith(substr, beg=0,end=len(string))
#检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
`案例`
>>str = 'www.baidu.com'
>>print(str.startswith('www',0,3))
>>del str
>>str = 'jd.123.com'
>>print(str.startswith('jde',0,3))
--结果
True
False
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
34 strip([chars])
#在字符串上执行 lstrip()和 rstrip()
Python strip() 方法用于移除字符串头尾指定的字符（默认为空格）或字符序列。
注意：该方法只能删除开头或是结尾的字符，不能删除中间部分的字符。
`案例`
>>str = "****www.baidu.com--&&-***"
>>print(str.strip("*"))
--结果
www.baidu.com--&&- --只删除开头和结尾是*的内容
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
35 swapcase()
#将字符串中大写转换为小写，小写转换为大写
`案例`
>>str = "WWW.BAIdu.com"
>>print(str.swapcase())
--结果
www.baiDU.COM
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
36 title()
#返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
#就是说所有单词的首字母都转化为大写。
`案例`
>>str = "www.baidu.com"
>>print(str.title())
>>str = '123w,1w2w3w,4c5d'
>>print(str.title())
--结果
Www.Baidu.Com
123W,1W2W3W,4C5D --非字母后的第一个字母会被转换为大写
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
37 translate(table, deletechars="")
#根据 table 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
语法
translate()方法语法：
str.translate(table)
bytes.translate(table[, delete])
bytearray.translate(table[, delete])
参数
table -- 翻译表，翻译表是通过 maketrans() 方法转换而来。
deletechars -- 字符串中要过滤的字符列表。
`案例`
>>intab = "aeiou"
>>outtab = "12345"
>>trantab = str.maketrans(intab, outtab) # 制作翻译表
>>str = "this is string example....wow!!!"
>>print (str.translate(trantab))
--结果
th3s 3s str3ng 2x1mpl2....w4w!!!
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
38 upper()
#转换字符串中的小写字母为大写
`案例`
>>table = 'asdas1312,888'
>>print(table.upper())
--结果
ASDAS1312,888
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
39 zfill (width)
#返回长度为 width 的字符串，原字符串右对齐，前面填充0
`案例`
str = 'www.baidu.com '
print(str.zfill(17))
--结果
00www.baidu.com --返回17个字符的内容,不够补0
40 isdecimal()
#检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。
`案例`
>>str = 'www.baidu.com '
>>print(str.zfill(17))
>>str = '678'
>>print(str.isdecimal())
--结果
00www.baidu.com
True
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
7.列表
7.1 使用方法
1.序列是 Python 中最基本的数据结构。
序列中的每个值都有对应的位置值，称之为索引，第一个索引是 0，第二个索引是 1，依此类推。
Python 有 6 个序列的内置类型，但最常见的是列表和元组。
#通过索引列表可以进行截取、组合等操作。
`案例`
#coding utf-8
#author *****
list = [1,2,3,4,5,6]
print(list[0:4])
`结果`
[1, 2, 3, 4] --遵循左闭右开原则不包含4--[)
索引也可以从尾部开始，最后一个元素的索引为 -1，往前一位为 -2，以此类推。
7.2 更新列表
`案例`
#coding utf-8
#author *****
list = ['google','baidu','yamzon','taobao']
print('列表的第三个元素为:',list[2])
list[2] = '4399.com'
print('更新后的第三个元素为:',list[2])
print(list)
list.append('haha.com')
print('追加一个新元素后的内容为:',list)
`结果`
列表的第三个元素为: yamzon
更新后的第三个元素为: 4399.com
['google', 'baidu', '4399.com', 'taobao']
追加一个新元素后的内容为: ['google', 'baidu', '4399.com', 'taobao', 'haha.com']
7.3 删除列表元素
`案例`
#coding utf-8
#author *****
list = ['google','baidu','yamzon','taobao']
print('删除前的列表为:',list)
del list[3]
print('删除后的列表为:',list)
`结果`
删除前的列表为: ['google', 'baidu', 'yamzon', 'taobao']
删除后的列表为: ['google', 'baidu', 'yamzon']
7.4 列表脚本操作符
| Python 表达式 |
结果 |
描述 |
| len([1, 2, 3]) |
3 |
长度 |
| [1, 2, 3] + [4, 5, 6] |
[1, 2, 3, 4, 5, 6] |
组合 |
| [‘Hi!’] * 4 |
[‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] |
重复 |
| 3 in [1, 2, 3] |
True |
元素是否存在于列表中 |
| for x in [1, 2, 3]: print(x, end=" ") |
1 2 3 |
迭代 |
#coding utf-8
#author *****
list = ['google','baidu','yamzon','taobao']
print(len(list)) --打印出列表的长度,一个元素为一个字符
print(list[1]*4) --打印出列表的索引为1的元素,重复4次
if 'baidu' in list: --如果baidu在列表中打印true
print("true")
for i in list[0:3]: --遍历list的0-3的元素,给i赋值并输出i,不换行
print(i,end="")
`结果`
4
baidubaidubaidubaidu
true
googlebaiduyamzon
7.5 列表截取与拼接
L=['Google', 'Runoob', 'Taobao']
Python 表达式 结果 描述
L[2] 'Taobao' 读取第三个元素
L[-2] 'Runoob' 从右侧开始读取倒数第二个元素: count from the right
L[1:] ['Runoob', 'Taobao'] 输出从第二个元素开始后的所有元素
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
列表拼接
#coding utf-8
#author *****
list = [1,2,3,4,5]
list += [6,7,8,9,10]
print(list)
`结果`
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
7.6 嵌套列表&列表比较
#coding utf-8
#author *****
list1 = ['a','b','c']
list2 = [1,2,3]
new_list = [list1,list2]
print(new_list)
print(new_list[0][1]) --输出列表0中的1元素
`结果`
[['a', 'b', 'c'], [1, 2, 3]]
b
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
列表比较需要引入 operator 模块的 eq 方法： --eq与shell--eq一致等于
`案例`
import operator
a = [1,2]
b = [2,3]
c = [2,3]
print("a是否等于b:",operator.eq(a,b))
print('c是否等于b:',operator.eq(c,b))
`结果`
a是否等于b: False
c是否等于b: True
7.6.1 operator内置模块
#Python 3.X 的版本中已经没有 cmp() 函数，如果你需要实现比较功能，需要引入 operator 模块，适合任何对象，包含的方法有
operator.lt(a, b) --less than:小于
operator.le(a, b) --less equal:小于等于
operator.eq(a, b) --equal ==
operator.ne(a, b) --!=
operator.ge(a, b) --greater equal:大于等于
operator.gt(a, b) --greater than:大于
operator.__lt__(a, b)
operator.__le__(a, b)
operator.__eq__(a, b)
operator.__ne__(a, b)
operator.__ge__(a, b)
operator.__gt__(a, b)
运算符函数
operator 模块提供了一套与 Python 的内置运算符对应的高效率函数。例如，operator.add(x, y) 与表达式 x+y 相同。
`案例`
#coding utf-8
#author *****
import operator
a = 3
b = 4
#add()让俩个值相加
print("add()运算结果:",end="") --end="":不换行输出,及下面行的打印会和此行合并
print(operator.add(a,b))
#sub()让俩个值相减
print("sub相减:",end="")
print(operator.__sub__(a,b))
#mul()让俩个值相乘
print("mul相乘",end="")
print(operator.__mul__(a,b))
`结果`
add()运算结果:7
sub相减:-1
mul相乘:12
7.7 列表函数&方法
1.line(list)
#列表元素个数
`案例`
#coding utf-8
#author *****
list1 = ['Google', 'Runoob', 'Taobao']
print (len(list1))
if 'list' in locals().keys(): # 判断一下list这个变量是否被定义了
del (list) # 如果被定义则删除
list2 = list(range(5))
print(len(list2),list2)
`结果`
3
5 [0, 1, 2, 3, 4]
2.max(list)
#返回列表元素最大值
`案例`
list1 = ['Google', 'Runoob', 'Taobao']
print(max(list1[0:2])) --打印出0-2元素中的最大值,根据索引进行比较
list1 = [1,2,3,7,5]
print(max(list1))
`结果`
Runoob
7 --整数型的列表按照内容数值进行比较
#可以看出列表中元素为字符串的时候，max 函数的比较是根据 id 的大小来判断的。
3.min(list)
#返回列表元素最小值
`案例`
#coding utf-8
#author *****
list1,list2 = [1,2,3,7,5],['Google','baidu','str']
print(min(list1),min(list2))
print(id(list2[0]),id(list2[1]),id(list2[2]))
if id(list2[0]) > id(list2[1]):
print("true")
`结果`
1 Google
1442604729320 1442604728760 1442599766704
true
4.list(seq)
#将元组转换为列表
`案例`
#coding utf-8
#author *****
tuple = (123,'google',213,'baidu')
list1 = list(tuple)
print('元组列表转换为:',list1[0:2])
str1 = 'Hello World'
new_list = list(str1)
print("新的列表内容为:",new_list)
`结果`
元组列表转换为: [123, 'google']
新的列表内容为: ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd'] --字符串连同空格会被拆解
7.8 列表函数
1.list.append(obj)
#在列表末尾添加新的对象
`案例`
#coding utf-8
#author *****
list1 = ['Google','Runnbo','Taobao']
list1.append('baidu')
print(list1)
`结果`
['Google', 'Runnbo', 'Taobao', 'baidu']
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
2.list.count(obj)
#统计某个元素在列表中出现的次数
`案例`
#coding utf-8
#author *****
alist = [123,'Google','Runnbo',123]
a = 123
print("123在列表中出现的次数为:",alist.count(a))
print('Gooogle元素出现的次数为:',alist.count('Google'))
`结果`
123在列表中出现的次数为: 2
Gooogle元素出现的次数为: 1
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
3.list.extend(seq)
#在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
`案例`
#coding utf-8
#author *****
alist = [123,'Google','Runnbo',123]
alist_2 = list(range(5))
alist.extend(alist_2)
print("新的列表内容为:",alist)
`结果`
新的列表内容为: [123, 'Google', 'Runnbo', 123, 0, 1, 2, 3, 4]
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
4.list.index(obj)
#从列表中找出某个值第一个匹配项的索引位置
语法
index()方法语法：
list.index(x[, start[, end]])
参数
x-- 查找的对象。
start-- 可选，查找的起始位置。
end-- 可选，查找的结束位置。
`案例`
#coding utf-8
#author *****
list1 = ['Google','baidu','alibaba']
print('Google的索引位置为:',list1.index('Google'))
print('alibaba的索引位置为',list1.index('alibaba',1-2)) --从1的索引位置开始
`结果`
Google的索引位置为: 0
alibaba的索引位置为 2
5.list.insert(index, obj)
#将对象插入列表
参数
index -- 对象obj需要插入的索引位置。
obj -- 要插入列表中的对象。
`案例`
#coding utf-8
#author *****
list1 = ['Google','baidu','alibaba']
list1.insert(1,'jingdong')
print("在元素1后插入新的元素:",list1)
`结果`
在元素1后插入新的元素: ['Google', 'jingdong', 'baidu', 'alibaba']
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
6.list.pop([index=-1])
#移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
`案例`
#coding utf-8
#author *****
list1 = ['Google','baidu','alibaba']
list1.insert(1,'jingdong')
list1.pop()
print('取出索引最后位的值抛弃后的列表为:',list1)
list1.pop(0)
print("取出第一位:",list1)
`结果`
取出索引最后位的值抛弃后的列表为: ['Google', 'jingdong', 'baidu']
取出第一位: ['jingdong', 'baidu']
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
7.list.remove(obj)
#移除列表中某个值的第一个匹配项
`案例`
#coding utf-8
#author *****
list1 = ['Google','baidu','alibaba']
list1.remove('Google')
print("移除列表中的Google",list1)
`结果`
移除列表中的Google ['baidu', 'alibaba']
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
8.list.reverse()
#反向列表中元素
`案例`
#coding utf-8
#author *****
list1 = ['Google','baidu','alibaba']
list1.reverse()
print('列表元素反转:',list1)
`结果`
列表元素反转: ['alibaba', 'baidu', 'Google']
9.list.sort( key=None, reverse=False)
#对原列表进行排序
参数
key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。
`案例`
#coding utf-8
#author *****
list1 = ['a','e','i','b','d']
list1.sort(reverse=True) --使用降序排序
print(list1)
`结果`
['i', 'e', 'd', 'b', 'a']
`案例2`
#coding utf-8
#author *****
def takeSecond(elem): --定义函数体,只有调用的时候才会生效
return elem[1] --返回elem中的元素1
random = [(2, 2), (3, 4), (4, 1), (1, 3)]
random.sort(key=takeSecond) --以元素1进行排序
print('排序列表:',random)
`结果`
排序列表: [(4, 1), (2, 2), (1, 3), (3, 4)]
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
10. list.clear()
#清空列表
#coding utf-8
#author *****
list1 = ['Google','baidu','jingdong','alibaba']
list1.clear()
print(list1)
`结果`
[]
+----+-------------+---------+------------+------+---------------+------+---------+------+------+----------+-------------+
11.list.copy()
#复制列表
`案例`
#coding utf-8
#author *****
list1 = ['Google','baidu','jingdong','alibaba']
list2 = list1.copy()
print(list2)
`结果`
['Google', 'baidu', 'jingdong', 'alibaba']
8. 元组
8.1 基础学习
1.Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号 ( )，列表使用方括号 [ ]。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
--定义元组
>>> tup1 = ('Google', 'Runoob', 1997, 2000)
>>> tup2 = (1, 2, 3, 4, 5 )
>>> tup3 = "a", "b", "c", "d" # 不需要括号也可以
>>> tup4 = () # 创建空元组
元组中只包含一个元素时，需要在元素后面添加逗号 , ，否则括号会被当作运算符使用：
>>> tup1 = (50)
>>> type(tup1) # 不加逗号，类型为整型
<class 'int'>
>>> tup1 = (50,)
>>> type(tup1) # 加上逗号，类型为元组
<class 'tuple'>
8.2 访问元组
`案例`
#coding utf-8
#author *****
tup1 = ('Google','Runnbo',1997,2000)
tup2 = (1,2,3,4,5,6,7)
print("tup1[0]:",tup1[0])
print("tup2[1]:",tup2[1])
`结果`
tup1[0]: Google
tup2[1]: 2
8.3 修改元组
#元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，
`案例`
#coding utf-8
#author *****
tup1 = ('Google','Runnbo',1997,2000)
tup2 = (1,2,3,4,5,6,7)
tup3 = tup1 + tup2
print(tup3,tup3[4])
`结果`
('Google', 'Runnbo', 1997, 2000, 1, 2, 3, 4, 5, 6, 7) 1
删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:
`案例`
#coding utf-8
#author *****
tup1 = ('Google','Runnbo',1997,2000)
print(tup1)
del tup1
print("删除后的元组:",tup1)
print(tup1)
`结果`
('Google', 'Runnbo', 1997, 2000)
NameError: name 'tup1' is not defined
8.4 元组运算符
与字符串一样，元组之间可以使用 +、+=和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。
| Python 表达式 |
结果 |
描述 |
len((1, 2, 3)) |
3 |
计算元素个数 |
>>> a = (1, 2, 3) >>> b = (4, 5, 6) >>> c = a+b >>> c (1, 2, 3, 4, 5, 6) |
(1, 2, 3, 4, 5, 6) |
连接，c 就是一个新的元组，它包含了 a 和 b 中的所有元素。 |
>>> a = (1, 2, 3) >>> b = (4, 5, 6) >>> a += b >>> a (1, 2, 3, 4, 5, 6) |
(1, 2, 3, 4, 5, 6) |
连接，a 就变成了一个新的元组，它包含了 a 和 b 中的所有元素。 |
('Hi!',) * 4 |
(‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’) |
复制 |
3 in (1, 2, 3) |
True |
元素是否存在 |
for x in (1, 2, 3): print (x, end=" ") |
1 2 3 |
迭代 |
8.5 元组索引截取
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：
`案例`
#coding utf-8
#author *****
tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')
print(tup[0:-3])
print(tup[0:])
print(tup[-5:])
`结果`
('Google', 'Runoob', 'Taobao')
('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
8.6 内置函数
| 序号 |
方法及描述 |
实例 |
| 1 |
len(tuple) 计算元组元素个数。 |
>>> tuple1 = ('Google', 'Runoob', 'Taobao') >>> len(tuple1) 3 >>> |
| 2 |
max(tuple) 返回元组中元素最大值。 |
>>> tuple2 = ('5', '4', '8') >>> max(tuple2) '8' >>> |
| 3 |
min(tuple) 返回元组中元素最小值。 |
>>> tuple2 = ('5', '4', '8') >>> min(tuple2) '4' >>> |
| 4 |
tuple(iterable) 将可迭代系列转换为元组。 |
>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu') |
9.字典
9.1基础学习
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 key=>value 对用冒号 : 分割，每个对之间用逗号(,)分割，整个字典包括在花括号 {} 中 ,格式如下所示：
# 使用大括号 {} 来创建空字典
emptyDict = {}
# 打印字典
print(emptyDict)
# 查看字典的数量
print("Length:", len(emptyDict))
# 查看类型
print(type(emptyDict))
结果:
{}
Length: 0
<class 'dict'>
9.2 访问字典
#coding utf-8
#author *****
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print("tinydict:name=",tinydict['Name'])
print("tinydict:age=",tinydict['Age'])
tinydict:name= Runoob
tinydict:age= 7
9.3 修改字典
#coding utf-8
#author *****
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 8 ##修改字典中的age的值
tinydict['school'] = '清华大学' ##字典中增加新的键值对
print("age=",tinydict['Age'])
print("school=",tinydict['school'])
print(len(tinydict),tinydict.keys()) ##打印字典的键值对个数以及所有的键
9.4 删除字典元素
#coding utf-8
#author *****
tinydict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
tinydict['Age'] = 20
tinydict['school'] = '清华大学'
del tinydict['Age'] #删除字典中的age
tinydict.clear() #清空字典中的键值对
print(len(tinydict),tinydict.values())
print(tinydict['Name'])
9.5 字典内置函数
1.Python 字典 copy() 函数返回一个字典的浅复制。
语法
copy()方法语法：
dict.copy()
#coding utf-8
#author *****
dict1 = {'Name':'Runbbo','Age':'18','Class':'First'}
dict2 = dict1 # 浅拷贝: 引用对象(软连接)
dict3 = dict1.copy() ## 深拷贝：深拷贝父对象（一级目录），子对象（二级目录）不拷贝，子对象是引用
dict1['Name'] = '****'
print(dict1)
print(dict2)
print(dict3)
{'Name': '****', 'Age': '18', 'Class': 'First'}
{'Name': '****', 'Age': '18', 'Class': 'First'}
{'Name': 'Runbbo', 'Age': '18', 'Class': 'First'}
##浅拷贝和深拷贝的区别:浅拷贝跟随原内容的变化而变化,深拷贝进行复制产生新的内容不会随着原内容改变而改变.
2.Python 字典 fromkeys() 函数用于创建一个新字典，以序列 seq 中元素做字典的键，value 为字典所有键对应的初始值。
语法
fromkeys() 方法语法：
dict.fromkeys(seq[, value])
seq -- 字典键值列表。
value -- 可选参数, 设置键序列（seq）对应的值，默认为 None。
#coding utf-8
#author *****
seq = ('name','age','class')
dict1 = dict.fromkeys(seq)
print("产生的字典为:%s" % str(dict1)) ##%s引入后面变量中的字符串,%非字符串内容
dict2 = dict.fromkeys(seq,10)
print("产生的字典为:",dict2)
产生的字典为:{'name': None, 'age': None, 'class': None}
产生的字典为: {'name': 10, 'age': 10, 'class': 10}
3.Python 字典 get() 函数返回指定键的值。
key -- 字典中要查找的键。
value -- 可选，如果指定键的值不存在时，返回该默认值。
#coding utf-8
#author *****
tinydict = {'Name': 'Runoob', 'Age': 27}
print(tinydict.get('Name'),tinydict.get('Age'))
print(tinydict.get('hahah',123))
Runoob 27
123
4.Python 字典 in 操作符用于判断键是否存在于字典中，如果键在字典 dict 里返回 true，否则返回 false。
而 not in 操作符刚好相反，如果键在字典 dict 里返回 false，否则返回 true
#coding utf-8
#author *****
thisdict = {'Name': 'Runoob', 'Age': 7}
key="Age"
if key in thisdict:
print(f'键{key}存在') ##字符串中调用变量
else:
print(f'键{key}不存在')
键Age存在
