python-数据类型-总结

已于 2022-09-26 10:23:29 修改
阅读量527 收藏 1
点赞数
文章标签： python 开发语言
于 2022-09-26 10:21:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sores/article/details/127048781
版权

0.可变类型和不可变数据

不可变对象，该对象所指向的内存中的值不能被改变。当改变某个变量时候，由于其所指的值不能被改变，相当于把原来的值复制一份后再改变，这会开辟一个新的地址，变量再指向这个新的地址。
不可变数据类型：数值类型（int和float）、字符串str、元组tuple

可变对象，该对象所指向的内存中的值可以被改变。变量（准确的说是引用）改变后，实际上是其所指的值直接发生改变，并没有发生复制行为，也没有开辟新的出地址，通俗点说就是原地改变。
可变数据类型：列表list、字典dict、集合set

1.字符串[str]

1.1 字符串声明

#使用 '' 或者 " " 来声明str
# message1= 'This is a string in Python'
# message2= "This is also a string"
# print(message1)
# print(message2)

#使用'''长字符串'''
# help_message = '''
# Usage: mysql command
#     -h hostname     
#     -d database name
#     -u username
#     -p password 
# '''

# print(help_message)

1.2 字符串拼接

#字符串拼接：
    # c="aaa" "bbbb"
    # print(c)  #自动拼接     结果：aaabbbb

#使用+ 拼接字符串
    # greeting = 'Good '  
    # time = 'Afternoon'
    
    # greeting = greeting + time + '!'
    # print(greeting)   #Good Afternoon!

1.3 转义和格式化输出【重要】

1.3.1 转义
#字符串转义
# c="aaa\tb\nbb" #转义
# e="aaa\\tb\\nb" #转义

【推荐】
# d=r"aaa\tb\bb" #r""   忽略转义 直接显示

# print(c)    #编译器将特殊符号直接翻译了 \t 制表符   \n 换行符
# print(e)    #aaa\tb\nb  使用\将转义的特殊符号打印出来
# print(d)    #aaa\tb\bb

1.3.2 格式化输出（%，format，f-string）

1.3.2.1：三种方法性能对比
【例子】
name="wxf" 
age=99 
print('%s age is %s'%(name,age))
print('{} age is {}'.format(name,age))
print(f'{name} age is {age}')
【结果】
wxf age is 99
wxf age is 99
wxf age is 99


【性能对比】
import timeit

a=timeit.timeit("""name="wxf" 
age=43  
'%s age is %s'%(name,age)""",number=10000)
print("% ",a)

a=timeit.timeit("""name="wxf" 
age=43  
'{} age is {}'.format(name,age)""",number=10000)
print("format",a)

a=timeit.timeit("""name="wxf" 
age=43  
f'{name} age is {age}'""",number=10000)
print("f-string",a)
【结果】
%  0.0016807000000000002
format 0.0016438000000000008
f-string 0.0008855000000000009

【补充见https://cloud.tencent.com/developer/article/1693332】

1.3.2.2 %【了解】
%s  字符串
%d  有符号的十进制数
%f   浮点数
【例】
a = "四大天王：%s、%s、%s、%s" % ("刘德华","郭富城","张学友","黎明")
print(a)

1.3.2.3 format【常用】
#【注意】
# 1.format函数会自动将参数转换成一个元组，所以如果你本来想传入一个元组参数到format函数中的话，实际上参数为长度为1的元组中嵌套你传的元组。
# 所以前面的{0}，{1}，{2}…要改成 {0[0]} {0[1]}…
#2.format中数据可以多于前面模板中的参数，但绝不能少于参数，少于会报错IndexError: tuple index out of range

#case1：无顺序
    mystr=" hello {},code {}".format("zzz","gp")  #有顺序要求 ，并且format中数据可以多于前面模板中的参数，但绝不能少于参数
    print(mystr)    #结果：hello zzz,code gp
    
    #mystr="lalala hello {},lalal {}".format(*["zzz"]) #错误  结果报：IndexError: tuple index out of range--》元组越界
    #print(mystr)
    
    mystr="hello {},code {}".format(*["zzz","gp"])  
    print(mystr)    #结果：#hello zzz,code gp

#case2  指定顺序
    mystr="lalala hello {0},lalal {1}".format("zzz","gp") #{0}代表第一个参数
    print(mystr)   #结果lalala hello zzz,lalal gp
    
    #【常用】
    mystr="lalala hello {0},lalal {1}".format(*["zzz","gp"])   #传入参数为元组，列表等  常用于函数返回值穿参到format()后面值
    print(mystr)   ##结果lalala hello zzz,lalal gp
    
    mystr="lalala hello {0},lalal {1}".format(["zzz","gp"],"111")
    print(mystr)  #结果 lalala hello ['zzz', 'gp'],lalal 111
    
    mystr="lalala hello {0[0]},lalal {0[1]}".format(["zzz","gp"])
    print(mystr)  #结果 lalala hello zzz,lalal gp
    
    mystr="lalala hello {0[0]},lalal {0[1]}".format(("zzz","gp"))
    print(mystr)  #结果 lalala hello zzz,lalal gp

#case3：指定参数
    mystr="lalala hello {name},lalal {code}".format(name="zzz",code="gp")
    print(mystr)
    
    mystr="lalala hello {name},lalal {code}".format(**{"name":"zzz","code":"gp"}) #传入字典类型的参数 "**"自动解析字典内部键值对
    print(mystr)

1.3.2.4 f-string【推荐】
f-string 格式化字符串以 f 开头，后面跟着字符串，字符串中的表达式用大括号 {} 包起来，它会将变量或表达式计算后的值替换进去：

【例】
name="111"
print(f"{name}"+"aaa")  #结果111aaa

a=1
b=2
print(f'{a+b}') # 3
print(f'{a+1}') # 2
print(f'{1+5}') # 6

name='zhang'
age=15
print(f'{name} age is {age}') #结果 zhang age is 15

1.4 字符串不可变

【重点】
#字符串变量为不可变类型，一旦生成变量不能随时改变
#字符串属于不可变对象，不支持原地修改，如果需要修改其中的值，只能重新创建一个新的字符串对象[重点]

【例】
# b="asdasd"
# b[0]=2
# print(b)

# 错误如下：
#     Traceback (most recent call last):
#   File "d:\code\py\pynote\b.py", line 82, in <module>
#     b[0]=2
# TypeError: 'str' object does not support item assignment

# mystr = "hello world and itcast and itheima and Python"
#print(mystr.replace('and', 'he'))  # 默认都替换了 # 结果：hello world he itcast he itheima he Python
#print(mystr)  # 说明字符串是不可变类型，返回的值才是替换后的字符串，replace没有改变字符串本身内容   # 结果：hello world and itcast and itheima and Python
#mystr = mystr.replace("and","he")	# 重新赋值 
#print(mystr)    # 结果：hello world he itcast he itheima he Python

1.5 常用用法

1.5.1 切片
切片操作  
  语法:序列[开始位置下标:结束下标:步长]   
  注意：1.这里的序列可以是字符串,元组，列表
        
        1.切片始终以start为开始，stop结束，确保切片[start: stop]区间有值，否则为空表
        2.start/stop值为负代表从左往右倒数几个元素
        3.不包含结束位置 输出[start，end)
        4.步长是选取间隔，默认值为1  步长正负都可 （步长正负只决定切片方向，正为从左往右，负为从右往左）
【例】
#a=" asdasdasD,aSdaSd,sadas,d,s,ad,s,ad,,asd,,s,a,d,sa,ad"

# print(a[2]) #str 字符串相当于 数组  ，可以直接使用下标进行访问，下标 ：0 开头 ， -1 结尾 
# print(a[-1])  
# print(a[0])  

# print(a[2:4])  #字符串支持进行切片操作    正向切片a[2:4]相当于取[2,4) 不包括 4
# print(a[-5:-2])   #负向切片    a[-5:-2] 相当于  [-5,2)

# 步长正为从左往右切片，要求start 
# print(a[2:10:])    #结果 sdasdasD
# print(a[2:10:1])  #结果  sdasdasD
# print(a[2:10:2])  #步长为 2  结果：sads

 # 步长为负,从右往左切片，要求start>stop,从start开始
# print(a[2:10:-1])  #结果为空 
# print(a[10:2:-1])  # 结果 ,Dsadsad
# print(a[10:2:-2])  # 结果 ,sda

# print(a[::])  #正序输出 asdasdasD,aSdaSd,sadas,d,s,ad,s,ad,,asd,,s,a,d,sa,ad
# print(a[::2]) # 结果 adsaDadS,aa,,,dsa,ad,,,,aa
# print(a[::-1]) #逆序输出   结果：asdasdasD,aSdaSd,sadas,d,s,ad,s,ad,,asd,,s,a,d,sa,ad

1.5.2 查找(index，find)

find和index区别

【区别】只是按值查找时，查找不到时，index会抛出异常，find只会返回-1.

1.5.2.1 index
#index()  # 根据值定位 返回第一次出现的索引值 
【语法】index(value,start,end) 
注	1.start和end可以省略，表示在整个字符串序列中查找
2.查找成功返回为第一次出现该值的第一索引位置
3.如果查找不成功，则会报ValueError错误  【可以使用try... except 处理该异常】

【例】
mystr = "hello world and itcast and itheima and Python"
# 其中三个and 首次索引分别是 12，23，35
【异常处理】
try:
	print(mystr.index("ands"))
except ValueError :
	print("An exception occurred")

【正常】
print(mystr.index("and"))  #12
	
print(mystr.index("and",1,15)) #12
	
print(mystr.index("and",13,))   #23
	
print(mystr.index("and",13,30))  #23

1.5.2.2 find【常用】
find()：检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则返回-1。
【语法】find(value,start,end) 
    注	1.start和end可以省略，表示在整个字符串序列中查找
        2.find 查找成功返回索引值，查找不成功返回 -1
【例】
mystr = "hello world and itcast and itheima and Python"
# 其中三个and 首次索引分别是 12，23，35
print(mystr.find("and"))  #12
print(mystr.find("ands")) #找不到返回 -1
print(mystr.find("and",0,15))	#12
print(mystr.find("and",13,-1))  #23

1.5.2.3 count
count()：返回某个子串在字符串中出现的次数。
【语法】：count(value,start,end) 
    注	1.start和end可以省略，表示在整个字符串序列中查找
 
【例】
mystr = "hello world and itcast and itheima and Python"
# 其中三个and 首次索引分别是 12，23，35
print(mystr.count("and"))  #3
print(mystr.count("ands")) # 0 

print(mystr.count("and",0,)) #3
print(mystr.count("and",0,15)) #1
print(mystr.count("and",13,30)) #1

1.5.3 修改

1.5.3.1 replace
#语法：replace（旧，新，替换次数） 注：替换次数如果超出子串出现次数，则替换次数为该子串出现次数

【例】
mystr = "hello world and itcast and itheima and Python"

print(mystr.replace('and', 'he'))  # 默认都替换了 # 结果：hello world he itcast he itheima he Python

print(mystr.replace('and', 'he', 10))# 结果：hello world he itcast he itheima he Python

print(mystr)  # 说明字符串是不可变类型，返回的值才是替换后的字符串   # 结果：hello world and itcast and itheima and Python

mystr = mystr.replace("and","he")
print(mystr)  # 说明字符串是不可变类型，返回的值才是替换后的字符串   # 结果：hello world he itcast he itheima he Python

1.5.3.2 split【常用】
# split() 分割 根据指定字符进行分割  return list 
【语法】split(分割字符，num)  
    [注意]：1.num表示的是分割字符出现的次数，即将来返回数据个数为num+1个
            2.分割字符不指定的话，默认以空格进行划分

【例】
#a=" asdasdasD,aSdaSd,sadas,d,s,ad,s,ad,,asd,,s,a,d,sa,ad"
print(a.split(",")) # 结果：[' asdasdasD', 'aSdaSd', 'sadas', 'd', 's', 'ad', 's', 'ad', '', 'asd', '', 's', 'a', 'd', 'sa', 'ad']
print(a.split(",")[0]) #结果： asdasdasD

print(a.split(",",2)) #可以指定切割最大次数  #结果[' asdasdasD', 'aSdaSd', 'sadas,d,s,ad,s,ad,,asd,,s,a,d,sa,ad']

mystr = "  hello world and itcast and itheima and Python"

print(mystr.split()) # ['hello', 'world', 'and', 'itcast', 'and', 'itheima', 'and', 'Python']

1.5.3.3 join【常用】
语法：	join(seq)  以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串

【例】
list1 = ['wo', 'shi', 'zhang', 'san']
t1 = ('aa', 'b', 'cc', 'ddd')

print('_'.join(list1)) #wo_shi_zhang_san
print(' '.join(list1)) #wo shi zhang san
print(''.join(list1))  #woshizhangsan
# print('...'.join(t1))  # 结果：aa...b...cc...ddd

a='...'.join(t1) 
print(type(a))  #<class 'str'>
print(a.split("..."))  #['aa', 'b', 'cc', 'ddd']

1.5.3.4 strip【常用】
#strip()  #去除收尾字符  默认是删除两端的空格，如果指定字符串，则删除指定字符串

mystr = "    Hello Wrld Dnd itcast and itheima and Python    "
print(mystr.strip())        #Hello Wrld Dnd itcast and itheima and Python
mystr = "Hello Wrld Dnd itcast and itheima and PythonH"
print(mystr.strip("H"))        #ello Wrld Dnd itcast and itheima and Python

1.5.3.5 其他（大小写相关）
其他：
mystr = "Hello Wrld Dnd itcast and itheima and Python"

print(mystr.lower())    #显示全为小写
print(mystr.upper())    #显示全为大写
print(mystr.title())    #将字符串每个单词首字母转换成大写
print(mystr.capitalize())   #只将字符串第一个字符转换成大写
【结果】
hello wrld dnd itcast and itheima and python
HELLO WRLD DND ITCAST AND ITHEIMA AND PYTHON
Hello Wrld Dnd Itcast And Itheima And Python
Hello wrld dnd itcast and itheima and python

1.5.4 判断

startswith【常用】识别日志类型
startswith(子串，开始下标，结束下标) #检查字符串是否以指定子串开头，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。
【例】
mystr = "hello world and itcast and itheima and Python"

print(mystr.startswith("he")) 
print(mystr.startswith("hello"))
print(mystr.startswith("hello "))
print(mystr.startswith("hello",0,))
print(mystr.startswith("hello",5,))
print(mystr.startswith("hello",5,20))
【结果】
True
True
True
True
False
False

endswith【常用】于区分文件类型

endswith()：检查字符串是否以指定子串结尾，是则返回 True，否则返回 False。如果设置开始和结束位置下标，则在指定范围内检查。

【例】
print(mystr.endswith("python"))
print(mystr.endswith("Python"))
print(mystr[0:15])
print(mystr.endswith("and",0,15))
【结果】
False
True
hello world and 
False

isalnum

isalnum() #如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False

isalpha

isalpha() #如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False

isdigit

isdigit()#如果字符串只包含数字则返回 True 否则返回 False…

1.6 用法大全

capitalize()把首字符转换为大写。
casefold()把字符串转换为小写。
center()返回居中的字符串。
count()返回指定值在字符串中出现的次数。
encode()返回字符串的编码版本。
endswith()如果字符串以指定值结尾，则返回 true。
expandtabs()设置字符串的 tab 尺寸。
find()在字符串中搜索指定的值并返回它被找到的位置。
format()格式化字符串中的指定值。
format_map()格式化字符串中的指定值。
index()在字符串中搜索指定的值并返回它被找到的位置。
isalnum()如果字符串中的所有字符都是字母数字，则返回 True。
isalpha()如果字符串中的所有字符都在字母表中，则返回 True。
isdecimal()如果字符串中的所有字符都是小数，则返回 True。
isdigit()如果字符串中的所有字符都是数字，则返回 True。
isidentifier()如果字符串是标识符，则返回 True。
islower()如果字符串中的所有字符都是小写，则返回 True。
isnumeric()如果字符串中的所有字符都是数，则返回 True。
isprintable()如果字符串中的所有字符都是可打印的，则返回 True。
isspace()如果字符串中的所有字符都是空白字符，则返回 True。
istitle()如果字符串遵循标题规则，则返回 True。
isupper()如果字符串中的所有字符都是大写，则返回 True。
join()把可迭代对象的元素连接到字符串的末尾。
ljust()返回字符串的左对齐版本。
lower()把字符串转换为小写。
lstrip()返回字符串的左修剪版本。
maketrans()返回在转换中使用的转换表。
partition()返回元组，其中的字符串被分为三部分。
replace()返回字符串，其中指定的值被替换为指定的值。
rfind()在字符串中搜索指定的值，并返回它被找到的最后位置。
rindex()在字符串中搜索指定的值，并返回它被找到的最后位置。
rjust()返回字符串的右对齐版本。
rpartition()返回元组，其中字符串分为三部分。
rsplit()在指定的分隔符处拆分字符串，并返回列表。
rstrip()返回字符串的右边修剪版本。
split()在指定的分隔符处拆分字符串，并返回列表。
splitlines()在换行符处拆分字符串并返回列表。
startswith()如果以指定值开头的字符串，则返回 true。
strip()返回字符串的剪裁版本。
swapcase()切换大小写，小写成为大写，反之亦然。
title()把每个单词的首字符转换为大写。
translate()返回被转换的字符串。
upper()把字符串转换为大写。
zfill()在字符串的开头填充指定数量的 0 值。

2.列表[list]

2.0 声明

正常列表
#正常声明：
	a=['aaa','bbb','ccc','ddd']  #正常声明
	b=[1,2,3]

空列表
#空列表
	c=[] 		#声明空列表，空列表长度为0
	c1=[]*3		#该空列表*3  ,依然是[] ,长度为0

使用乘法声明

#使用乘法声明
	d=[0]*4		#使用乘法声明重复某一值得列表   [0, 0, 0, 0]
	d1=[b]*4    	#[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]] --d1 len: 4

使用类型转化函数
#使用类型转化函数
	a=['aaa','bbb','ccc','ddd']
	a1=('aaa','bbb','ccc','ddd')
	b=list(a1)
	print(b,type(b))

列表拼接

#列表拼接
	e=a+b       #两个列表直接拼接，使用‘+’实现
	e1=a+[]    		#['aaa', 'bbb', 'ccc', 'ddd'] --e1 len: 4   #加法拼接空列表长度没变

列表嵌套声明
#列表嵌套声明
	f=[a,b]     #支持列表嵌套  [['aaa', 'bbb', 'ccc', 'ddd'], [1, 2, 3]] --f len: 2
	f1=[a,[]]     	#[['aaa', 'bbb', 'ccc', 'ddd'], []] --f1 len: 2   

【例】
a=['aaa','bbb','ccc','ddd']
b=[1,2,3]
c=[]
c1=[]*3
d=[0]*4
d1=[b]*4
e=a+b
e1=a+[]    #['aaa', 'bbb', 'ccc', 'ddd'] --e1 len: 4
f=[a,b]
f1=[a,[]]     #[['aaa', 'bbb', 'ccc', 'ddd'], []] --f1 len: 2

print(a,'--a len:',len(a))
print(b,'--b len:',len(b))
print(c,'--c len:',len(c))
print(c1,'--c1 len:',len(c1))
print(d,'--d len:',len(d))
print(d1,'--d1 len:',len(d1))
print(e,'--e len:',len(e))
print(e1,'--e1 len:',len(e1))
print(f,'--f len:',len(f))
print(f1,'--f1 len:',len(f1))
【结果】
['aaa', 'bbb', 'ccc', 'ddd'] --a len: 4
[1, 2, 3] --b len: 3
[] --c len: 0
[] --c1 len: 0
[0, 0, 0, 0] --d len: 4
[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3]] --d1 len: 4
['aaa', 'bbb', 'ccc', 'ddd', 1, 2, 3] --e len: 7
['aaa', 'bbb', 'ccc', 'ddd'] --e1 len: 4
[['aaa', 'bbb', 'ccc', 'ddd'], [1, 2, 3]] --f len: 2
[['aaa', 'bbb', 'ccc', 'ddd'], []] --f1 len: 2


2.1 取值（索引,切片）【未完】

索引
#类似于根据下标来取列表值

切片
#切片操作

#切片修改

#切片删除

2.2 增

insert（index,value）
insert(index,value)：列表在索引位置中插入值为value元素

【例】
a=['aaa','bbb','ccc','ddd']
print(a)
a.insert(0,'111')  #首部插
print(a)

print(a[-1])
a.insert(-1,'222')  #尾部插  在原来末尾元素的位置插入，原来的元素依旧是最后一个元素
print(a)

a.insert(2,'333')  #正常插
print(a)

a.insert(8,'444')   #超过列表长度插入，放末尾
print(a)
【结果】
['aaa', 'bbb', 'ccc', 'ddd']
['111', 'aaa', 'bbb', 'ccc', 'ddd']
ddd
['111', 'aaa', 'bbb', 'ccc', '222', 'ddd']
['111', 'aaa', '333', 'bbb', 'ccc', '222', 'ddd']
['111', 'aaa', '333', 'bbb', 'ccc', '222', 'ddd', '444']

append
append(obj)：列表末尾添加新元素  【注】obj 表示到添加到列表末尾的数据，它可以是单个元素，也可以是列表、元组等。

a.append('eee')
print(a)		#['aaa', 'bbb', 'ccc', 'ddd', 'eee']

a.append([1,2,3])  #传递列表或者元组时，此方法会将它们视为一个整体
print(a)  #['aaa', 'bbb', 'ccc', 'ddd', 'eee', [1, 2, 3]]

extend

extend(obj)：列表末尾追加一个序列，【注】该序列可以是单个元素，也可以是列表、元组等，但不能是单个的数字

#用序列单个数字
a=['aaa','bbb','ccc','ddd']
a.extend(5)  #用序列单个数字
print(a)     # TypeError

#序列为单个字符
a=['aaa','bbb','ccc','ddd']
a.extend('d')  #用序列单个字符
print(a)     #['aaa', 'bbb', 'ccc', 'ddd', 'd']

#序列字符串
a=['aaa','bbb','ccc','ddd']
b=[1,2,3]
a.extend('ffff')  #用序列字符串，将字符串中一个字符一个一个加入
print(a)    #['aaa', 'bbb', 'ccc', 'ddd', 'f', 'f', 'f', 'f']

序列为列表和元组
a=['aaa','bbb','ccc','ddd']
b=[1,2,3]
a.extend(b)  #序列为列表
print(a)     #['aaa', 'bbb', 'ccc', 'ddd', 1, 2, 3]

a.extend((3,4,6)) #  #序列为元组
print(a)     #['aaa', 'bbb', 'ccc', 'ddd', 1, 2, 3, 3, 4, 6]

extend() 和 append() 的不同

extend() 和 append() 的不同之处在于：extend() 不会把列表或者元祖视为一个整体，而是把它们包含的元素逐个添加到列表中。

2.3 删

del

del 是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。

【例1】
lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]

# #使用正数索引
# del lang[2]
# print(lang)    #['Python', 'C++', 'PHP', 'Ruby', 'MATLAB']

# #使用负数索引
# del lang[-2]
# print(lang)    #['Python', 'C++', 'PHP', 'MATLAB']

【例2】
#使用切片删除删除中间一段连续的元素
【注意】#start 表示起始索引，end 表示结束索引。del 会删除从索引 start 到 end 之间的元素，不包括 end 位置的元素
lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
del lang[1:3]
print(lang)    #['Python', 'PHP', 'Ruby', 'MATLAB']

pop

pop(index)：根据index索引值进行删除元素（默认最后一个）并返回。[类似于栈的出栈]

remove

remove(value):根据值进行删除元素
【注】remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误。

clear
 clear() 用来删除列表的所有元素，也即清空列表  直接变成空列表[]
	
【例】
a=['aaa','bbb','ccc','ddd']

a.clear()
print(a) #[]

2.4 查

index

根据值来查询索引位置，返回值为索引位置
【语法】index(value,start,end)
【注】

  1. 正常返回 返回第一次出现该值索引位置
  2. 该值未找到（包括对于指定start，end区间中找不到），则会报 ValueError 【可以使用try… except 处理该异常】
  3. start和end可以省略，表示在整个序列中查找
a=['aaa','bbb','ccc','ddd']

print(a.index("ccc"))     # 2
# print(a.index("ccsdas"))  # ValueError

in/not in
in/not in：字面意思，返回值为bool值

a=['aaa','bbb','ccc','ddd']
b=[1,2,3]
print('ccc' in a)    #True
print('ccc' not in a)  #False
print('ccc' not in b)   #True

count

计算列表中的某个元素个数

a_list = [2, 30, 'a', [5, 30], 30]
# 计算列表中30的出现次数
print(a_list.count(30)) 	# 2
# 计算列表中[5, 30]的出现次数
print(a_list.count([5, 30])) 	# 1

2.5 改&排序

reverse

直接自己逆置

a=['aaa','bbb','ccc','ddd']
a.reverse()
print(a)    #['ddd', 'ccc', 'bbb', 'aaa']

sort

sort排序可以指定排序方式，升序和降序【默认升序】（降序需要设置参数是将reverse值设置为TRUE）

a=['aaa','asdbb','cdbc','bdd']
a.sort()  #根据第一个字符来排序
print(a)    #['ddd', 'ccc', 'bbb', 'aaa']  

b=[1,8,9,6,7,15]
b.sort()
print(b)   #[1, 6, 7, 8, 9, 15]

#设置排序方式
b=[1,8,9,6,7,15]
b.sort(reverse=True)
print(b) # [15, 9, 8, 7, 6, 1]

b=[1,8,9,6,7,15]
b.sort(reverse=False)
print(b)   #[1, 6, 7, 8, 9, 15]

【异常】
b=[1,8,9,6,7,15,'asdasd']
b.sort()
print(b)    #TypeError: '<' not supported between instances of 'str' and 'int'

2.6 遍历

常用两种遍历方法
lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]
#for
#case1
	for i in lang:
					print(i)
	#case2
	for i,value in enumerate(lang,start=1):
					print(i,'-->','value')   # --> value

#while		
	mystring = "Microsoft Windows [ 10.0.22000.856] (c) Microsoft Corporatio"
	length = len(mystring)
	i=0
	while i < length:
			print(mystring[i])
			i+=1

#[反向遍历]
for i in  reverse(lang):
	print(i)

2.8 列表格式化字符串【未完】

mystr="lalala hello {0},lalal {1}".format(*["zzz","gp"])   #传入参数为元组，列表等  常用于函数返回值穿参到format()后面值
print(mystr)   ##结果lalala hello zzz,lalal gp

2.9 列表反转和原地翻转【面试】

lang = ["Python", "C++", "Java", "PHP", "Ruby", "MATLAB"]

#方法1：使用reversed内置函数,返回值为迭代器，使用list方法进行类型转换
l1=list(reversed(lang))
# print(l1)

#方法2 切片反向遍历复制新的列表
l2=lang[::-1]
# print(l2)

#方法3 倒序遍历添加到新的列表
l3=[]
index=len(lang)-1
while index >= 0:
        l3.append(lang[index])
        index = index-1
# print(l3)

#方法4原地逆置【重点】
def change(list,index1,index2):
        temp=list[index1]
        list[index1]=list[index2]
        list[index2]=temp
        return list

def reverse(list):
        lenth=len(list)
        if lenth % 2 ==0:    #偶数
                for i in range(int(lenth/2)):
                        list=change(list,i,lenth-i-1)
        else:  奇数
                for i in range(round(int(lenth/2))):
                        list=change(list,i,lenth-i-1)
        return list

def reverse1(list):
        lenth=len(list)
        end=0
        mid=lenth/2   #索引的中间值
        if lenth % 2 ==0:
                end=int(mid)
        else:
                end=round(int(mid))
        for i in range(end):
               list=change(list,i,lenth-i-1)     

        return list
	
# print(reverse(lang))
print(reverse1(lang))

#方法五  list反转函数reverse
a=['aaa','bbb','ccc','ddd']
a.reverse()
print(a)    #['ddd', 'ccc', 'bbb', 'aaa']

2.10 列表和元组的区别

元组与列表很相似，两者都表示一个有序的序列，它们的区别在于：
	列表创建后，可以进行修改
	元组创建后，不能进行修改

3.元组[tuple] 【未完】

声明

取值

常用函数

4.字典[dict] 【未完】

声明

增

删

del

改

#根据key直接改对应value
#使用update()

查

info={
        'name': 'Bob',
        'age':'25',
        'sex':'male',
        'hobby':'game',
}
#直接使用key值拿值
print(info['age'])  #25

#使用get函数，根据key返回值，找不到就返回none
#print(info.get('age'))  #25
#print(info.get('aaa'))  #None

#items()，返回所有的键值对
print(info.items()) #dict_items([('name', 'Bob'), ('age', '25'), ('sex', 'male'), ('hobby', 'game')])

#keys(),返回字典的所有key值
print(info.keys())  #dict_keys(['name', 'age', 'sex', 'hobby'])

#values()，返回字典的所有值
print(info.values()) #dict_values(['Bob', '25', 'male', 'game'])

遍历

info={
        'name': 'Bob',
        'age':'25',
        'sex':'male',
        'hobby':'game',
}
#遍历
for key,value in info.items():
        print('key:value',key,":",value)   #key:value name : Bob

#遍历
for i,item in enumerate(info.items(),start= 1):
        print('(i:items)',i,":",item)      #(i:items) 1 : ('name', 'Bob')

#遍历
for i,(key,value) in enumerate(info.items(),start= 1): 
        print('(i-->key:value)',i,key,":",value)     #(i-->key:value) 1 name : Bob

使用字典格式化字符串

 mystr="lalala hello {name},lalal {code}".format(**{"name":"zzz","code":"gp"}) #传入字典类型的参数 "**"自动解析字典内部键值对
 print(mystr)

用法大全

方法描述
keys()返回包含字典键的列表
values()返回字典中所有值的列表
items()返回包含每个键值对的元组的列表
pop()删除拥有指定键的元素
popitem()删除最后插入的键值对
clear()删除字典中的所有元素
get()返回指定键的值
fromkeys()返回拥有指定键和值的字典
update()使用指定的键值对字典进行更新
copy()返回字典的副本
setdefault()返回指定键的值。如果该键不存在，则插入具有指定值的键。

5.集合[set]【了解】 【未完】

zsoros
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Python数据类型详细介绍
m0_61232019的博客
03-27 1万+
一、数字（Number） 1. int （整型，长整型） 2. float (浮点型） 3. complex（复数） 二、布尔（Boolean） 三、字符串类型（String） 四、列表 1. 创建列表 2. 列表的索引 3. 列表的切片 4. 列表加法和乘法 5.列表的修改 6. 列表的删除 7. 列表追加、插入和扩展 8. 列表元素查找 9. 列表相关的相关内置函数 10.多维列表 五、元组 1. 元组相关概述 2. 元组修改 3. 元组删除
python变量类型-python变量的数据类型有哪些？
weixin_37988176的博客
11-01 1846
现实生活中，我们在超市买东西的时候，往往都需要使用购物车来存储物品，等到所有的物品都购买完成后，在收银台进行结账即可。 大家试想一下，如果程序中要对多个数据求和，就需要把这些数据先存储起来，再对这些数据进行累加。在python中，若要存储数据，需要用到变量。变量可以理解为去超市购物使用购物车，他的类型和值在赋值的那一刻被初始化。变量的赋值是通过符号来表示的，示例代码如下：num_one = 100...
速看！！！python史上最全数据类型总结
weixin_49016330的博客
07-22 2962
Python是一种强大的编程语言，提供了丰富的数据类型来处理不同的数据。在本博客中，我们将介绍Python中的常见数据类型，并了解它们的特点和用法。Dict是Python中表示无序、可变的键值对集合的数据类型。Set是Python中表示无序、不重复元素的集合的数据类型。Float类型的变量也可以进行数学运算，甚至可以进行高级的数学计算，如三角函数和指数运算。Dict类型的变量可以通过键来访问对应的值，可以进行添加、删除和修改键值对等操作。Int类型的变量可以进行常见的数学运算，如加法、减法、乘法和除法。
Python数据类型汇总（详细解读）大全
weixin_62044613的博客
07-21 7261
进阶学习python的九种数据类型IntFloatBoolStrNoneListTupleDicSet五种基本数据类型（int、str、bool、float、none）
Python史上最全数据类型，拿走不谢！_全额 数据类型
最新发布
2401_84140506的博客
04-27 405
True 表示肯定的答案有，是，好的，没错，真的…False 表示否定的答案没有，不是，错，假的…复数的完整结构(实数部分+虚数部分)声明复数的两种方式：表达式方式：变量 = 实数 + 虚数 如：var = 3 + 2j特定功能：变量 = complex(实数，虚数值) 如：var = complex(5,3)
python数据类型总结
qq_41166909的博客
04-27 1127
数据类型 python有6中数据类型，也就是类，具体为变量 number:数字型 string:字符串类型 list:列表类型 tuple:元组 dictionary:字典 set:集合 三种数值类型： 整形(int),浮点型(float),复合类型(complex) 函数名 描述 int(x) 将对象x转化成整形 float(x) 将对象x转化成浮点型 str(x) 将对象x转化成字符串类型 tuple(s) 将序列s转化成元组 list(s) 将序列s转化成列表 se
Python常用数据类型总结
12-21
Python常用数据类型总结 文章目录Python常用数据类型总结一.数值二.字符串三.格式化字符串四.布尔值和空值五.类型检查及转换 一.数值 在Python数值分成了三种： 整数、浮点数（小数）、复数 1.int类型 在Python中...
深入实践Python-GDAL地理数据处理源码总结
03-25
本项目致力于深入实践Python-GDAL库在地理数据处理方面的应用，并对此进行了全面的源码总结。项目主要采用Python语言编写，包含总计126个文件，具体文件类型分布如下： - Python脚本文件（.py）：32个 - 图像文件...
python数据类型总结-xmind
02-01
python数据结构的总结，基于xmind编辑。 总结多年来遇到的python数据类型以及使用注意事项
python-3.8.6-amd64
04-27
1. 数据科学与机器学习：Python在数据分析和机器学习领域有广泛的应用，如Pandas、NumPy、Matplotlib、Scikit-learn等库，为数据处理和模型构建提供了强大支持。 2. 网络编程：Python的`socket`库使得网络编程变得...
基于python-pptx库中文文档及使用详解
09-17
总结起来，python-pptx库提供了丰富的功能来帮助用户创建和编辑PowerPoint文件。通过使用这个库，你可以自动化创建报告，动态生成数据可视化，甚至构建复杂的演示文稿。只要熟悉其API，就可以实现灵活且高效的PPTX...
python常见数据类型总结
m0_61286600的博客
09-12 772
python数据容器列表(list)、字符串(str)、元组(tuple)、集合(set)、字典(dict)的总结，包括序列总结，具体使用方法等
python数据类型总结_python数据类型（总结篇）
weixin_39979167的博客
11-28 116
世界上最容易的事是坚持，最难的事也是坚持。开通博客园已两月有余，但实际上笔者本人的活跃度非常低，痛定思痛，自己选的路含泪也要走下去，继续坚持！本文承接前几个月的python数据类型系列，完成对字典与集合两种数据类型的介绍，并结束python数据类型系列。字典是python语言中常用的数据类型之一，顾名思义，一个字典就是许多“键值对”的集合，一个键值对就是字典的一个数据元素，示例如下：从上图可以看到...
python-数据类型总结（集合，元组，列表，字典）
m0_65188455的博客
04-29 1294
集合，列表，元组
【Python基础篇】Python中的七种数据类型
热门推荐
qq_44723773的博客
01-14 2万+
a = b[begin, end, step]，begin表示开始位置，默认为0，end表示结束位置，默认为变量长度，step表示步长，默认为1。从存储的角度来理解，浅拷贝就是增加了指针指向值的存储地址，并没有对值开辟新的内存空间进行存储，深拷贝则是开辟新的内存空间去存储并指针指向新的内存地址。如果从相对简单的角度来理解的话，浅拷贝和深拷贝是针对嵌套对象的区别，对原数据的嵌套对象的修改，浅拷贝对应的嵌套对象会同步影响，深拷贝就不会受影响。列表是以[]定义，用英文逗号分隔开的集合，元素是可以重复的。
Python数据类型总结
益久科技-IT外包服务
11-02 380
概述 在Python中，一切皆为对象！数据类型也不例外。 Python中所有数据类型、数据结构都是类，每个变量都是类的实例。 没有基础数据类型的概念，但标准库中拥有一个小的内建类型集合，这类“单值”类型为了方便有时被称为标量类型。 Python有6种数据类型：数字、字符串、元组、列表、集合、字典。（布尔类型是int的子类） 我们分两大部分来介绍，一部分，是基础类型，或者说标量类型，主要是数字和字符...
python的输入输出
chenshaoshakalaka的博客
05-07 1646
最近刚入手python 笔记开始 程序中出现中文或者其他非英语的语言 在第一行输入# -*- coding: UTF-8 -*- 或#coding=utf-8 python的输入为input 例 a = input("此处为提示语")#变量a获得了一个你从键盘输入的字符串类型(str)的变量 python的输出为print 例print("字符串")输出为字符串 print(1+1)输出为2 print(a)输出位变量a的值 print("1...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值