天天看点
返回

python字符串,集合,列表,元组,字典一.字符串字符串运算及操作二.列表四.字典五.集合

一.字符串

字符串是Pyhton中最常见的数据类型。我们可以使用引号（‘或“)来创建字符串。事实上,在pyhton中,加了引号的字符都被认为是字符串

python中单个字符和多个字符用引号包裹后,统称为字符串,没有java或者C中字符的说法

name = "骚姐姐"
age = "18"
age_1 = 18
msg = '''I'm Tang you''' #单引号会就近重合，使用三个单引号会避免 三单引号三双引号可以换行使用
msg = """I'm Tang you"""
print(type(name),type(age),type(age_1),type(msg))

<class 'str'> <class 'str'> <class 'int'> <class 'str'>

字符串运算及操作

数字可以进行加减乘除等运算,字符串呢？让我告诉你,也能?what?是的,但只能进行"相加"和"相乘"运算

1拼接

>>>a="hello"
>>>b="pyhton"
>>>a+b
'helloPython'

注意,字符串的拼接只能是双方都是字符串,不能跟数字或其他类型拼接

>>>age_1=5000
>>>name+age_1
Traceback(most recent call last):
  File"<stdin>",line 1,in<module>
TypeError: must be str,not

2.重复(*)

a="hello"
print(a*5)

3.切片和索引

>>> a="Life is short,I use python"
>>> len(a)
26
>>>
>>> a[0]#索引
'L'
>>> a[16]
'u'
>>> a[-4]
't'
......
>>> a[:15]#切片
'Life is short,I'
>>> a[15:2]
''
>>> a[15::2]
' s yhn'
>>> a[::-1]
'nohtyp esu I,trohs si efiL'
>>>

4.大小写转换

str.lower():转小写
 str.upper():转大写
 str.swapcase():大小写对换
 str.capltalize():字符串首为大写,其余小写
 str.title():以分隔符为标记,首字符为大写,其余为小写
 举例:>>>a="life is short,I use python"
>>>a.lower()#将所有大写字符转换为小写字符
'life is short,i use python'
>>>a.upper()#将所有小写字符转换为大写字符
'LIFE IS SHORT,I USE PYTHON'
>>>a.swapcase()#将所有小写字符变成打成,将大写字符变成小写
'lIFE IS SHORT, i USE PYTHON'
>>>a.capltalize()#将字符串的第一个字符大写
'Life is short, i use python'
>>>a.title()#返回标题化的字符串
'Life Is Short, I Use Python'

5.字符串格式输出对齐

str.center()居中
 a="Life is my love"
a.center(35,"*")
'**********Life is my love**********' #返回一个原字符串居中,并使用空格填充至长度width的新字符串
str.ljust()左对齐
>>> a.ljust(35,"*")
'Life is my love********************'
#返回一个原字符左对齐,并使用空格填充至长度width的新字符串
 str.rjust()右对齐
    >>> a="Life is short,I use python"
>>> a.rjust(35,"*")
'*********Life is short,I use python'#返回一个原字符串右对齐，并使用空格填充至长度width的新字符串
 str.zfill()
    >>>a.zfill(35)#返回长度为width的字符串,原字符串string右对齐,前面填充0,只有一个参数
'000000000Life is short,I use python'

6.删除指定字符

str.lstrip()删除左边空格
 a="****life isshort, I use python****" #删除左边指定字符串
>>> a.lstrip("*")
str.rstrip()删除右边空格
'life isshort, I use python****' #删除右边指定字符串
>>> a.rstrip("*")
str.stri()删除所有空格
>>> a.strip("*")
'life isshort, I use python'

7.计数

EXCEL表中:

计数=countif(B2:B31,">=30")/count(B2:B31)

8.字符串搜索定位与替换

str.find()
>>> a="Life is short,I use python"
>>> a.find("e")#查找元素并返回第一个出现的索引值
3
>>> a.find("e",18,24)
18
>>> a.find("w")
-1
>>>
str.index()和find()方法一样,只不过如果str不在string中会报一个异常。
>> a="Life is short,I use python"
>>> a.index("e")
3
>>> a.index("e",18)
18
>>>a.index("w")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>>
str.rindex()和index方法一样,但是从右边开始
str.replace()>>> a="Life is short,I use python"
>>> a.replace("I use","You need")
'Life is short,You need python'
>>> a.replace("t","T")
'Life is shorT,I use pyThon'
>>> a.replace("t","T",1)
'Life is shorT,I use python'

9.字符串条件判断

isalnum()，字符串由字母或数字组成，
isalpha()，字符串只由字母组成，
isdigit()，字符串只由数字组成
           
In [1]: a = "abc123"

In [2]: b = "ABC"

In [3]: c = 123

In [4]: a.isalnum()
Out[4]: True

In [5]: a.isalpha()
Out[5]: False

In [6]: a.isdigit()
Out[6]: False

In [7]: b.isalnum()
Out[7]: True

In [8]: b.isalpha()
Out[8]: True

In [9]: b.isdigit()
Out[9]: False>>> str = '01234'
 
>>> str.isalnum()   # 是否全是字母和数字，并至少有一个字符
True
>>> str.isdigit()    # 是否全是数字，并至少有一个字符
True      
 
 
>>> str = 'string'
 
>>> str.isalnum()  # 是否全是字母和数字，并至少有一个字符
True
>>> str.isalpha()  # 是否全是字母，并至少有一个字符 
True
>>> str.islower() # 是否全是小写，当全是小写和数字一起时候，也判断为True
True
 
>>> str = "01234abcd"
 
>>> str.islower() # 是否全是小写，当全是小写和数字一起时候，也判断为True
True
 
>>> str.isalnum()  # 是否全是字母和数字，并至少有一个字符
True
 
>>> str = ' '
>>> str.isspace()  # 是否全是空白字符，并至少有一个字符
True
 
>>> str = 'ABC'
 
>>> str.isupper()   # 是否全是大写，当全是大写和数字一起时候，也判断为True
True
 
>>> str = 'Aaa Bbb'
 
>>> str.istitle()  # 所有单词字首都是大写，标题 
True
 
 
>>> str = 'string learn'
 
>>> str.startswith('str') # 判断字符串以'str'开头
True
 
>>> str.endswith('arn')  # 判读字符串以'arn'结尾
True

10.制表符转化

str.expandtabs()
>>> a = "L\tife is short, I use python"
>>> a.expandtabs() # 默认将制表符转化为8个空格
'L       ife is short, I use python'
>>> a.expandtabs(4) # 加上参数，将制表符转化为对应个数的空格
'L   ife is short, I use pythons
>>>
  1. 011ASCII码和字符的转化 
chr():用一个范围在range(256)内的(就是0~255)整数作参数，返回一个对应的字符。
ord():将一个ASCII字符转换为对应的数字
chr(65)
\#结果：'A'
ord('a')
\#结果：97

12字符串分割变换

join()将指定字符插入到元素之间;
#join
>>> str="learn string"
>>> "-".join(str)
'l-e-a-r-n- -s-t-r-i-n-g'
>>> "+".join(str)
'l+e+a+r+n+ +s+t+r+i+n+g'
>>> "*".join(str)
'l*e*a*r*n* *s*t*r*i*n*g'
split()以指定字符分隔序列去除该字符
#split
>>> str.split("n")
['lear', ' stri', 'g']
>>> str.split("n",1)
['lear', ' string']
>>> str.rsplit("n",1)
['learn stri', 'g']
>>> str.splitlines()
['learn string']
 partition()以指定字符串分隔序列且包含该字符
>>> str.partition("n")
('lear', 'n', ' string')
>>> str.rpartition("n")
('learn stri', 'n', 'g')

补充:

string模块 

>>> import string
>>> dir(string)
['Formatter', 'Template', '_ChainMap', '_TemplateMetaclass', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_re', '_string', 'ascii_letters', 'ascii_lowercase', 'ascii_uppercase', 'capwords', 'digits', 'hexdigits', 'octdigits', 'printable', 'punctuation', 'whitespace']
>>> string.ascii_letters
'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.ascii_lowercase
'abcdefghijklmnopqrstuvwxyz'
>>> string.ascii_uppercase
'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
>>> string.capwords("hUNAN yingxiao college")
'Hunan Yingxiao College'
>>>

string模块中的capwords()函数功能: 

1.将每个单词首写字母置为大写
2.将每个单词除首字母外的字母均置为小写
3.将词语词之间的多个空格用一个空格代替
4.其拥有两个参数,第二个参数用以判断单词之间的分割符,默认为空格
           
>>> string.digits
'0123456789'
>>> string.hexdigits
'0123456789abcdefABCDEF'
>>> string.octdigits
'01234567'
>>> string.printable
'0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~ \t\n\r\x0b\x0c'
>>> string.punctuation
'!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
>>>

二.列表

列表是python中的基础数据类型之一，其他语言中也有类似于列表的数据类型，比如js中叫数组，他是以[]括起来，每个元素以逗号隔开，而且他里面可以存放各种数据类型比如：

li = [‘ex’,123,Ture,(1,2,3,’sir’),[1,2,3,’小明’,],{‘name’:’ex’}]

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据，32位python的限制是 536870912 个元素,64位python的限制是 1152921504606846975 个元素。而且列表是有序的，有索引值，可切片，方便取值。

特点:是一个有序的可以重复的序列可变类型

1.创建一个空列表。

list1=[]
print(type(list1))

2.创建一个有多个值的列表,每个值用逗号隔开

list1=[17,25,16,22,28]

列表也可以存放不同类型的元素

lst2=[17,"str",[16,22,28],(66,67),{'name':'Tom','age'：18}]

列表索引和切片

lst2=[17,"str",[16,22,28],(66,67),{'name':'Tom','age'：18}]
len(lst2)
lst2[0]
18
lst2[3]
(66,67)
lst2[-1]
{'name':'tom','age':18}
lst2[3:]
[(66,67),{'name:'Tom','age':18}]
lst2[0::2]
[18,[1,2,3],{'name':'Tom','age':18}]

列表的常见操作

列表:name=['a','b','c','d']

1.增加

append():增加到最后
names=['a','b','c','d']
names.append('e')
print(names)
['a', 'b', 'c', 'd', 'e']
names=['a','b','c','d']
names.append([1,2,3])
print(names)
['a', 'b', 'c', 'd', [1, 2, 3]]
extend():迭代的去增
names=['a','b','c','d']
place=['hunan','guangdong','guangxi']
names.extend(place)
print(names)
['a', 'b', 'c', 'd', 'hunan', 'guangdong', 'guangxi']
insert()：按照索引去增加
names=['a','b','c','d']
names.insert(2,'devilf')
print(names)
['a', 'b', 'devilf', 'c', 'd']
其他的插入方法:
names=[3]
names[0]='lebron'
print(names)
['lebron']

2删除

pop()
names=['a','b','c','d']
names.pop()  #如果没有指定下标,则默认删除最后一个元素
print(names)
names=['a','b','c','d']
names.pop(2)  #指定索引时就会删除索引所对应元素
print(names)
names=['a','b','c','d']
names
print(names)
['a', 'b', 'c']
['a', 'b', 'd']
['a', 'b', 'c', 'd']
remove():按照元素删除
names=['a','b','c','d','e','f','e']
names.remove('e')
print(names)
['a', 'b', 'c', 'd', 'f', 'e']
del():
names=['a','b','c','d','e','f','e']
del names[4]
print(names)
['a', 'b', 'c', 'd', 'f', 'e']
clear():
names = ['a', 'b', 'c', 'd', 'e', 'f', 'e']
names.clear()
print(names)
[]

3改

li=['a','b','c','d']
li[1]='cc'
print(li)
['a', 'cc', 'c', 'd']
li=['a','cc','c','d']
li[0:2]=['aa','bb']
print(li)0
['aa', 'bb', 'c', 'd']

4.查

切片查,或者，循环去查 
索引,切片，遍历
1.查找元素所在位置:index()
2.遍历
三种:
(1)
li=["python","java","C++"]
for  i in li:
print(i ,end= " ")
python java C++   
（2）
for i in range(len(li)):
print(li[i], end=" ")
python java C++
(3)
li = ["python", "java", "C++"]
for i,li[i] in enumerate(li):
print(i,li[i])
0 python
1 java
2 C++

5.其他操作

1.统计元素的次数:count()

>>> names=['a','b','c','d']
>>> names.append('d')
>>> names.count('d')
2

2.反转:reverse()

>>> names=['a','b','c','d']
>>> names.reverse()
>>> names
['d', 'c', 'b', 'a']
>>>

3.排序:sort()按照ascii码来进行排序

>>> names=['a','b','c','d']
>>> names.insert(3,'&&')
>>> names
['a', 'b', 'c', '&&', 'd']
>>> names.sort()
>>> names
['&&', 'a', 'b', 'c', 'd']
>>> names.sort(reverse=True)
>>> names
['d', 'c', 'b', 'a', '&&']
>>> names[::-1]
['&&', 'a', 'b', 'c', 'd']
>>>

Python字符串格式化

尽管已经掌握了所介绍的字符串方法和序列操作，Python还提供了一种更高级的方法来组合字符串处理任务——字符串格式化允许在一个单个的步骤中对一个字符串执行多个特定类型的替换。它不是严格必须的，但它很方便使用，特别是当格式化文本以显示给程序的用户的时候。由于Python世界中充满了很多新思想，如今的Python中的字符串格式化可以以两种形式实现：

字符串格式化表达式
  这是从Python诞生的时候就有的最初的技术；这是基于C语言的“printf”模型，并且在大多数现有的代码中使用。
 字符串格式化方法调用
  这是Python2.6和Python3.0新增加的技术，这是Python独有的方法，并且和字符串格式化表达式的功能有很大重叠。
      Python在对字符串操作的时候定义了%二进制操作符（你可能还记得它在对数字应用时，是除法取余数的操作符）。当应用在字符串上的时候，%提供了简单的方法对字符串的值进行格式化，这一操作取决于格式化定义的字符串。简而言之，%操作符为编写多字符串替换提供了一种简洁的方法，而不是构建并组合单个的部分。
   格式化字符串、
1.在%操作符的左侧放置一个需要进行格式化的字符串，这个字符串带有一个或多个嵌入的转换目标，都以%开头（例如，%d）。
2.在%操作符右侧放置一个（或多个，嵌入到元组中）对象，这些对象将会插入到左侧想让Python进行格式化字符串的一个（或多个）转换目标的位置上去。

例如，在下列一个格式化示例中，整数1替换在格式化字符串左边的%d，字符串‘bird’替换%s。结果就得到了一个新的字符串，这个字符串就是这两个替换的结果：

print("No. %d:\tI'm a little little %s." % (1, "bird"))
No. 1:  I'm a little little bird.

从技术上来讲，字符串的格式化表达式往往是可选的一—通常你可以使用多次的多字符串的合并和转换达到类似的目的。然而格式化允许我们将多个步骤合并为一个简单的操作，这一功能相当强大，我们多举几个例子来看一看：

>>> say = "Hello"
>>> "Hello - %s" % say
'Hello - Hello'
>>> "%d %s %d %s" % (2, "hand", 2, "eye")
'2 hand 2 eye'
>>> "%s -- %s -- %s" % (3.14, 'pi', '山巅一寺一壶酒')
'3.14 -- pi -- 山巅一寺一壶酒'
>>>　
           
在第一个例子中，在左侧目标位置插入字符串"Hello"，代替标记%s。在第二个例子中，在目标字符串中插入三个值。需要注意的是当不止一个值待插入的时候，应该在右侧用括号把它们括起来（也就是说，把它们放到元组中去）。%格式化表达式操作符在其右边期待一个单独的项或者一个或多个项的元组。
　　第三个例子同样是插入三个值：一个整数、一个浮点数对象和一个列表对象。但是注意到所有目标左侧都是%s，这就表示要把它们转换为字符串。由于对象的每个类型都可以转换为字符串（打印时所使用的），每一个与%s一同参与操作的对象类型都可以转换代码。正因如此，除非你要做特殊的格式化，一般你只需要记得用%s这个代码来格式化表达式。
　　另外，请记住格式化总是会返回新的字符串作为结果而不是对左侧的字符串进行修改；

由于字符串是不可变的，所以只能这样操作。如前所述，如果需要的话，你可以分配一个变量名来保存结果。
           
表：字符串格式化代码
代码 意义
s 字符串（或任何对象）
r s，但使用repr，而不是str
c 字符
d 十进制（整数）i整数
u 无号（整数）八进位整数
o 八进制整数
x 十六进制整数
X x，但打印大写
e 浮点指数
E e，但打印大写
f 浮点十进制
F 浮点十进制
g 浮点e或f
G 浮点E或f
% 常量%

Fromat格式化(匹配花括号({}))

位置映射

str="{}唱歌好听，\n {}唱歌更好听".format("蒋新衡","吴振")
print(str)
str="{}---{}---{}".format("wz","jxh","wyf")
print(str)
蒋新衡唱歌好听，
 吴振唱歌更好听
wz---jxh---wyf

关键字映射

str="{0}---{name}---{1}".format("wz","jxh",name="wyf")
print(str)
wz---wyf---jxh
# str="{0}---{name}--{1}".format(("wz","jxh"),name="wyf")
# print(str)
  File "D:/Python_Demo/ASCII.py", line 11, in <module>
    str="{0}---{name}---{1}".format(("wz","jxh"),name="wyf")
IndexError: tuple index out of range
str="{0[0]}---{name}---{0[1]}".format(("wz","jxh"),name="wyf")
print(str)
wz---wyf---jxh
str="{0[0]}---{name}---{0[1]}".format(["wz","jxh"],name="wyf")
print(str)
wz---wyf---jxh

三.元组 

元组:是一个有序,可重复的,不可更改的对象;         
           
特点：
     1.与list类似;
     2.不可变的类型数据;
     3.元组使用的是()

元组的基本使用格式:

(元素1,元组2,...,元组n)
           
基本呢描述：
        元组是用()包裹起来的多个元素的数据类型,每个元素之间用","隔开

1.元组的创建 

1.创建一个空元组
t1 = ()
print(type(t1))
<class 'tuple'>
 st = ()
st1 = tuple()
print(st,st1)
((), ())
print( type(st), type(st1))
(<class 'tuple'>, <class 'tuple'>)

创建只含有一个元素的元组

需要注意的地方:我们创建的元组只含有一个元素的元组,我们必须在这仅有的一个元素后加上一个","。

t1=(6)
print(t1,type(t1))
(6, <class 'int'>)


 t1=(6, ) #只有一个元素的元组，必须加上","
print( t1, type(t1))
((6,), <class 'tuple'>)
  • 创建含有多个元素的元组

和列表一样,元组的元素也可以试试不同的数据类型的元素

2.元组的基本操作

查

  • 通过索引值查找对应元素 
t1=(1,"hunan",['h','u','n','a','n'],('I','love','you'),{"name":"Tom","age":18})
print(t1[4])
{'name': 'Tom', 'age': 18}
print(t1[-1])
{'name': 'Tom', 'age': 18}
print(t1[::-2])
({'name': 'Tom', 'age': 18}, ['h', 'u', 'n', 'a', 'n'], 1)
  • 查找元素的索引值 
t1=(1,"hunan",['h','u','n','a','n'],('I','love','you'),{"name":"Tom","age":18})
print(t1.index("hunan"))
1

注意:元组是不可变的数据类型:不能够增,删,改

t1=(1,"hunan",['h','u','n','a','n'],('I','love','you'),{"name":"Tom","age":18})
print(t1[0]=0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

注意到t1里有个列表,那么这个列表中的元素是否可以更改

t1=(1,"hunan",['h','u','n','a','n'],('I','love','you'),{"name":"Tom","age":18})
print(t1[2])
['h', 'u', 'n', 'a', 'n']
 t1[2][2]='N'
print(t1)
(1, 'hunan', ['h', 'u', 'N', 'a', 'n'], ('I', 'love', 'you'), {'name': 'Tom', 'age': 18})

2.元组的基本操作

1.拼接

t1=('唐友','蒋新衡','吴振','wyf')  #拼接
t2=('ty','jxh','wz','王余丰')
print(t1+t2)
('唐友', '蒋新衡', '吴振', 'wyf', 'ty', 'jxh', 'wz', '王余丰')

2.重复

t1=('唐友','蒋新衡','吴振','wyf')
print(t1*3)
('唐友', '蒋新衡', '吴振', 'wyf', '唐友', '蒋新衡', '吴振', 'wyf', '唐友', '蒋新衡', '吴振', 'wyf')

3.判断元素是否存在

t1=('唐友','蒋新衡','吴振','wyf')
print('wyf' in  t1)
print('wyf' not in t1)
t1=('唐友','蒋新衡','吴振','wyf')
print('wyf' in  t1)
print('wyf' not in t1)

4.最大小值

t1=('a','b','c')
print(max(t1))
c
print(min(t1))
a
元组遍历

1.值遍历

tp=('python','java','c++')
for i in tp:
  print(i,end=" ")
  python java c++

2.索引遍历

tp=("Python","Java","C++")
for  i in range(len(tp)):
     print(tp[i], end= " ")
     Python Java C++

3.索引-值,遍历

枚举(enumerate)对于一个迭代的(iterable)/可遍历的对象(如列表,字符串).enumerate将其组成一个索引序列,利用他可以同时获得索引和值。

tp=('Python','Java','C++')
for index,value in  enumerate(tp):
 print(index,':',value)
0 : Python
1 : Java
2 : C++
tp=('Python','Java','C++')
for index,value in  enumerate(tp,6):
 print(index,':',value)
 6 : Python
7 : Java
8 : C++

四.字典

思考：

场景1

如果有列表

li = ['Pyhton', 'Java', 'C++'];

需要对"pyhton"这个名字写错了，通过代码修改：

li[0] = "Python"

如果列表的顺序发生了变化，如下

li = ['Java', 'C++', 'Pyhton'];

此时就需要修改下标，才能完成名字的修改

li[2] = "Python"

有没有方法，既能存储多个数据，还能在访问元素的很方便就能够定位到需要的那个元素呢？

答：

字典

场景2：

学生信息列表，每个学生信息包括学号、姓名、年龄等，如何从中找到某个学生的信息？

studens = [[201801, "张三", 18], [201802, "李四", 19], [201803, "王二"，17], ...]

循环遍历？ 这样很麻烦。

实际生活中，我们还经常使用汉语字典，英汉词典等等。

程序中的字典:

info  = {"usrname":"Lilei","age": 18,"Class": "one"}

字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型，字典是一种可变数据类型，且可存储任意类型对象。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

格式:

{key1:value1,key2:value2,........}

描述:

1.键-值对中间用冒号(":")连接；

 2.key:value组成字典里的一个元素;

 3.键-值对(元素)之间用逗号(",")隔开；

 4.整个字典用花括号"{}"包裹起来。

字典的创建

创建一个空字典 

python

dict = {}

type(dict)

创建一个有多个值得字典

1.直接赋值法:d={key1:value1,key2:value2},如

info = {"usrname":"Lilei","age": 18,"Class":"two"}
print(info)
{'usrname': 'Lilei', 'age': 18, 'Class': 'two'}

拓展:

key1 = "name"
value1 = "Tom"
key2= "age"
value2 = 18
d={key1 : value1, key2 : value2}
print(d)
{'name': 'Tom', 'age': 18}
           
info = dict((('name', 'LiLei'), ('age', 18)))
info = dict([('name', 'LiLei'), ('age', 18)])
info = dict((['name', 'LiLei'], ['age', 18]))

3.通过字典的fromkeys方法创建字典

info = dict.fromkeys("Hello") # 如果没有指定默认值，默认为 None；
print( info)
{'H': None, 'e': None, 'l': None, 'o': None}
info = dict.fromkeys(["Lilei","Lee","Jack"], "123456") # 给每个元素设置默认值"123456";
print( info)
{'Lilei': '123456', 'Lee': '123456', 'Jack': '123456'}

字典的常见操作

字典值得访问(查的一种)

字典是无序的，不能通过索引值类获取值。

info = info[2]
报错

通过键(key)访问值(value)

key值不存在的时候,会报错

info={"username":"Lilei", "age": 18,"Class": "Two"}
info["username"] # 通过关键字访问对应的值
print(info["username"])
Lilei

info["age"]
print(info["age"])
18
info["usname"] # 没有对应的key，报错
报错

使用get访问值(value)

不确定字典中是否存在某个键而又想获取其值时，可以使用get方法，还可以设置默认值

当key不存在的，不会抛出异常，返回None。

info ={"name" : "Lilei", "age": 18}
info.get("name")
print(info.get("name"))
Lilei
# 当key不存在，不会抛出异常，返回 None
info.get("job")
print(type(info.get("job")))
<class 'NoneType'>

增

直接添加新键-值对

在使用 变量名[‘键’] = 数据 时，这个"键"在字典中，不存在，那么就会新增这个元素：

info = {"name":"Lilei", "age": 18}
info["job"]="IT"
print(info)
{'name': 'Lilei', 'age': 18, 'job': 'IT'}
dict.update()

把字典info1的键/值对更新到info里

当两个字典中的键不同时，把info1的键值插入到info中

当两个字典中存在相同键时，info1覆盖info的键值

# 当两个字典完全不相同时
info = {"name": "Lilei","age":18}
info1 ={"job": "IT","salary":10000}
info.update(info1)
print(info)
print(info1)
{'name': 'Lilei','age': 18, 'job': 'IT', 'salary': 10000}
{'job': 'It','salary': 10000}
# 当两个字典存在相同键时，会覆盖前面的键值
>>> info = {"name": "Lilei", "age" : 18}
>>> info2 = {"name": "Tom", "salary": 10000}
>>> info.update(info2)
>>> info
{'name': 'Tom', 'age': 18, 'salary': 10000}
>>> info2
{'name': 'Tom', 'salary' :10000}
>>>

删

del dict[keys] 

删除指定的元素/键-值对

 没有返回值
           
info = {'name': 'Tom', 'age': 18, 'salary': 10000}
del info["salary"]
print(info)
info = {'name': 'Tom', 'age': 18, 'salary': 10000}
del info["salary"]
print(info)

del dict

删除整个字典

info = {"name": "Lilei", "age": 18}
del info
 info
报错

dict.clear()

清空整个字典

info = {"name": "Lilei", "age": 18}
info.clear()
print(info)
{}

dict.pop(keys)

删除指定键-值对

info = {'name': 'Tom', 'age': 18, 'salary': 10000}
print(info.pop("age"))
18
print( info)
{'name': 'Tom', 'salary': 10000}
  • dict.popitem()
  • 随机删除字典中的一组键值对
  • 有返回值，以元组的方式返回
  • 应用不广泛 
info ={'name': 'Tom', 'age': 18, 'salary': 10000}
print(info.popitem())
('salary', 10000)
print(info)
{'name': 'Tom', 'age': 18}

改

字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

直接修改

info = {'name':'Tom','age': 18, 'salary': 10000}
info["name"] = "Lilei"
print(info)
{'name': 'Lilei', 'age': 18, 'salary': 10000}

dict.setdefault()

键存在，不改动，返回字典中字典中相应的值

键不存在，在字典中添加相应的键值对，并返回相应的值

# 键存在，不改动，返回字典中相应的值
info = {'name': 'Tom','age': 18,'salary': 10000}
print(info.setdefault("age", 20)) # 有返回值
18
print(info )
{'name': 'Tom', 'age': 18, 'salary': 10000}
# 键不存在，在字典中添加相应的键值对，并返回相应的值
info = {"name": "Lilei", "age" : 18}
info2 = {"name": "Tom", "salary": 10000}
info.update(info2)
print(info)
print(info2)
{'name': 'Tom', 'age': 18, 'salary': 10000}
{'name': 'Tom', 'salary': 10000}

           
dict.keys()
 返回字典中的所有键(keys)
    dict.values()
 返回字典中的所有值(values)
  dict.items()
返回字典中的所有键-值对(keys-values)
某元素是否存在：
  key in dict
   存在，TRUE
   不存在,false
           
info = {'name': 'Tom','age': 18, 'salary': 10000}
print(info.keys())
dict_keys(['name','age','salary'])

print(info.values())
dict_keys(['Tom',18,10000])

print(info .items())
dict_item([('name','Tom'), ('age',18),('salary',10000)])
 
 print("age" in info)、
 True
 print( "job" in info)
 False

字典的遍历

(1) 遍历字典的键(key)

info = {"usename":"Lilei","age": 18,"Class":"one"}
for key in info.keys():
       print(key, end = " ")

(2) 遍历字典的值(value)

info = {"usrname":"Lilei","age": 18,"Class": "one"}
for value in info.values():
      print(value, end = " ")

(3) 遍历所有的项(items)

info = {"usrname":"Lilei","age": 18,"Class": "one"}
for item in info.items():
      print(item, end = " ")

(4)遍历字典的键-值对(key-value)

info = {"usrname":"Lilei","age": 18,"Class": "one"}
for key, value in info.items():
      print(key,":", value,end = " ")             print(key,":", value,end = " ")

五.集合 

集合是无序的,不重复的且不可以更改的数据集合它里面的元素是可哈希的(不可变的类型),但集合本身就是不可哈希(所以集合是做不了字典的键的),以下是集合最重要的两点：
    1.去重:把一个列表变成了集合,就在自动去重了
    2.关系:测试两组数据之前的交集,差集,并集等关系

集合的创建

创建一个空的集合

这里注意我们不可以直接用花括号"{}"

st=set()
print(st)
set()
st1={}
print(type(st),type(st1))
<class 'set'> <class 'dict'>

多元素的集合创建 

st={"a","b","c","d","e"}
print(st,type(st))
{'b', 'd', 'e', 'c', 'a'} <class 'set'>
st={1,2,3,[1,2]}
print(st)
Traceback (most recent call last):
  File "D:/Python_Demo/ks.py", line 78, in <module>
    st={1,2,3,[1,2]}
TypeError: unhashable type: 'list'
st={1,2,3,{"age:"18}}
print(str)
  File "D:/Python_Demo/ks.py", line 82
    st={1,2,3,{"age:"18}}
                      ^
SyntaxError: invalid syntax
   #不可以放列表和元组

集合的强转 

li=[1,"a","n","University"]
st_li=set(li)
print(st_li,type(st_li))
{1, 'n', 'University', 'a'} <class 'set'>
str="Universitysity"
st_str=set(str)
print(st_str,type(st_str))
{'r', 't', 'i', 'v', 'y', 'U', 'n', 's', 'e'} <class 'set'>
dic={"a":1,"b":2,"c":3,"d":4}
st_dic=set(dic)
print(st_dic,type(st_dic))
{'c', 'b', 'd', 'a'} <class 'set'>
  • list()
  • str()
  • tupel()
  • dict()
  • set()

    集合的基本操作

    查

    无序,

    不可查找

    增 

    set.add()
st={1,2,"Hunan","YingXiao","Collage"}
st.add("Computer Science")
print(st)
{1, 'Hunan', 2, 'Collage', 'Computer Science', 'YingXiao'}
set.update()
st.update("湖南","长沙")
print(st)
{'YingXiao', 1, 2, '湖', '沙', '南', '长', 'Collage', 'Hunan', 'Computer Science'}

    删 

    set.pop()
st={1,2,"Hunan","YingXiao","Collage"}
print(st.pop())#删除排序最小一的元素
print(st)
1
{2, 'Collage', 'Hunan', 'YingXiao'}
set.discard()
st={1,2,"Hunan","YingXiao","Collage"}
st.discard(2)#移除元素
print(st)
{1, 'YingXiao', 'Collage', 'Hunan'}
st.discard("HUNAN")#如果元素不存在,不会报错,不做任何操作
print(st)
{1, 'YingXiao', 'Collage', 'Hunan'}
set.remove()
st={1,2,"Hunan","YingXiao","Collage"}
st.remove(2)
print(st)
   {1, 'Hunan', 'Collage', 'YingXiao'}
st.remove("HUNAN")
print(st)
Traceback (most recent call last):
  File "D:/Python_Demo/ks.py", line 40, in <module>
    st.remove("HUNAN")
KeyError: 'HUNAN'
           
    set.clear()
st={1,2,3}
st.clear()
print(st)
set()
del set()
st={1,2,3}
del set
print(st)
  File "D:/Python_Demo/ks.py", line 46, in <module>
    del set
NameError: name 'set' is not defined

    改,不可以更改 

    st[0]="HUNAN"
print(st[0])
Traceback (most recent call last):
  File "D:/Python_Demo/ks.py", line 48, in <module>
    st[0]="HUNAN"
NameError: name 'st' is not defined
    遍历 
    st = {1, 2, "Hunan", "YingXiao", "Collage"}
for i in st:
    print(i,end= " ")
    1 2 Hunan YingXiao Collage 
    st = {1, 2, "Hunan", "YingXiao", "Collage"}
    for index ,value in enumerate(st):
        print(index, value)        
0 1
1 2
2 Hunan
3 Collage
4 YingXiao

比较

集合的基本运算

1.子集
a=set("abcd")
b=set("cdef")
c=set("ab")
print(a,b,c)
{'c', 'd', 'a', 'b'} {'e', 'd', 'f', 'c'} {'a', 'b'}
print(c.issubset(a))
True
print(c<a)
True
print(c<b)
Fals
2.交集
a=set("abcd")
b=set("cdef")
print(a.intersection(b))
print(a&b)
{'c', 'd'}
{'c', 'd'}
3.并集
a=set("abcd")
b=set("cdef")
print(a.union(b))
{'d', 'e', 'b', 'c', 'a', 'f'}
print(a|b)
{'d', 'e', 'b', 'c', 'a', 'f'}
4.差集
a=set("abcd")
b=set("cdef")
print(a.difference(b))
{'b', 'a'}
print(a-b)
{'b', 'a'}
python笔记
上一篇: 字符串 列表 字典 元组 集合
下一篇: Python内置序列之列表、元组、字符串、集合以及字典

继续阅读