Python中字符串，列表，元组，字典，个人总结！！！

目录

 

一.字符串

1. 字符串的定义及格式
2. 字符串的索引和切片
3. 字符串的查找
4. 字符串的拆分
5. 字符串的替换
6. 字符串的修饰
7. 字符串的格式化
8. 字符串的变形
9. 字符串的判断

二.列表

1. 列表的定义及格式
2. 列表的索引和for循环遍历列表
3.  列表的添加
4. 列表的删除
5. 列表的查询
6. 列表的修改
7. 列表的切片
8. 列表的排序和翻转
9. 列表的拷贝

三.元组

1. 元组的定义及创建
2. 元组的访问
3. 使用多个变量来接受元组的值
4. 元组中的方法

四.字典

1. 字典的定义及格式
2. 字典的增删查改
3. 字典的增加
4. 字典的删除
5. 字典的修改
6. 字典的查找
7. for循环及字典的遍历

 

 

 

 

 

---

 

一.字符串

1.字符串的定义及创建：

字符串是有序的，不可更改的，元素用引号包围的序列。

三引号，双引号或单引号中的数据就是字符串。例如："hello"      'world'

2.字符串的索引和切片：

索引：

注意：索引都是从0开始索引，如果是负数，则是从右向左开始索引。

s = [1, 2, 3, [5, 6, 7], 8, 9]
print(s[0])        # 输出列表中的第一个数            
print(s[-1])       # 输出列表中的最后一个数组         
print(s[3][-1])     # 输出列表中子列表的最后一个数    

输出结果：1     

                    9

                    7

切片：

s = [1, 2, 3, 4, 5, 6, 7, 8]
print(s[0:3])
print(s[1:5])           # s[start:end:step],从start开始，到end-1结束，步长为step
                        # step==2,就间隔一个字符；==3就间隔2个字符，依次递进
print(s[1:5:1])         # 从第二个数开始到第四个数结束 
print(s[:])             # 输出 所有字符
print(s[:4])            # 输出前4个字符  相当于[0:4]
print(s[::-1])          # 将字符倒叙输出
print(s[2:])            # 除了前两个字符，其余全部输出
print(s[-1:-4:-1])
print(s[-3::]) 
print(s[::-2])

输出结果：[ 1，2，3 ]

                     [ 2，3，4，5 ] 

                     [ 2,3,4,5 ]

                    [ 1,2,3,4,5,6,7,8 ]

                   [ 1,2,3,4]     

                   [ 8,7,6,5,4,3,2,1 ]

                  [ 3,4,5,6,7,8 ]

                   [ 8,7,6 ]

                  [ 6,7,8 ]          

                 [ 8,6,4,2 ]

3.字符串的查找：

s = 'Hello world Python'    注意：字符串中的空格也算在索引内

print(s.count('o'))        # 计算'o'在是中的个数。

print(s.find('l'))         # 查找，返回从左第一个指定字符的索引，找不到返回-1

print(s.find('c'))         # 字符串中没有发现就返回-1

print(s.rfind('o'))        # 字符串从右至左找第一个字符，但是索引是从左往右索引。

print(s.index('c'))        # 字符串中没有发现该字符，就会报错。
      
print(s.rindex('h'))       # 和rfind类似，但是找不到会报错



输出结果： 3
          2
          -1
          16
          ValueError: substring not found    #报错了
          15


               

4.字符串的拆分：

s = 'Hello world Python'

print(s.split('w'))    # 按照指定内容进行拆分，分为指定部分前 和指定部分后两部分。返回列表形式。

print(s.partition('orl'))   # 按照指定内容进行拆分，分为指定部分前 ，指定部分和 指定部分后三部
                              分，返回元组形式。
                              
s = 'Hello\n world\n Python'

print(s.splitlines())               # 按照换行符分割，返回列表的形式

print(s.splitlines(keepends=False))  # keepends=False   默认不显示换行符

print(s.splitlines(keepends=True))  # keppends=True       默认显示换行符


输出结果： ['Hello ', 'orld Python']
          ('Hello w', 'orl', 'd Python')
           ['Hello', ' world', ' Python']
            ['Hello', ' world', ' Python']
            ['Hello\n', ' world\n', ' Python']

5.字符串的替换：

s = 'Hello world Python'

print(s.replace('o', '0'))  # 将字符串中所有的o 替换成0 默认全部替换

print(s.replace('o', '0', 2))  # 第三个参数，是指定替换的个数


输出结果：    Hell0 w0rld Pyth0n
             Hell0 w0rld Python

----------------------------------------------------------------------------------
	translate	按照对应关系来替换内容 from string import maketrans

s = 'Hello world,'
a = 'world,'
b = 'python'
ret = str.maketrans(a,b)   
s1 = s.translate(ret)      # 必须一一对应
print（s1）


输出结果:   Hehhy python

6.字符串的修饰：

center：将字符串按指定长度居中，若果不能左短右长，可以指定填充内容，默认以空格填充。

s = 'hello'

print(s.center(10,'*'))   # 填充长度是10 ，用 * 填充

输出结果：**hello***
-------------------------------------------------------------------------------------
ljust：让字符串在指定的长度左齐，可以指定填充内容，默认以空格填充
	  
rjust：让字符串在指定的长度右齐，可以指定填充内容，默认以空格填充。

# ljust 和 rjust
s = 'hello'
print(s.ljust(15, '~'))
print(s.rjust(15, '*'))

输出结果：hello~~~~~~~~~~
         **********hello
-----------------------------------------------------------------------------------------
zfill:  将字符串填充到指定长度，不足的地方从左开始填充0

s = 'hello'

print(s.zfill(10))

输出结果：00000hello

7.字符串的格式化：

for.mat()用法：
   
    相对基本格式化输出采用'%'的方法，for.mat()功能更强大，通过传入参数进行格式化，并使用大括号{}代替%

1.使用位置参数：位置必须一一对应：

name = 'zs'

age = 19

print('大家好，我叫{}，今年{}岁'.format('zs',age)     # 位置必须一一对应

print('大家好，我叫{0}，我叫{0}，我叫{0}，今年{1}岁'.format('zs',age) 

输出结果：大家好，我叫zs，今年19岁
         大家好，我叫zs，我叫zs，我叫zs，今年19岁

2.使用关键字参数：

print('我叫{name}，今年{age}岁了'.format(name = 'zs'，age = 19))

输出结果：我叫zs，今年19岁了

8.字符串的变形：

# upper   将字符串中所有字母转换为大写  

# lower   将字符串中所有字母转化为小写

# swapcase 将字符串中字母大小写互换

# title    将字符串中单词首字母转化为大写 

# capitalize 只有字符串首字母大写

# expandtabs 将字符串中tab（'\t'）符号转化为空格
-------------------------------------------------------------------------------------
s = 'Hello python'

print(s.upper())

print(s.lower())

pow(s.swapcase())

print(s.title())

print(s.capitalize())

s1 = 'hello\tpython'

print(s.expandtabs())

输出结果：HELLO PYTHON
                  hello python

                  hELLO PYTHON
                  Hello Python
                  Hello python
                  hello   python    

     9.字符串的判断：

大部分判断都是返回bool型

s = 'Hello123'
print(s.isalnum())              #  True       判断字符串是否完全由数字和字母组成

s1 = 'abcde'
print(s1.isalpha())              # True        判断字符串是否完全由字母组成

s2 = 'abc123'
print(s2.isdigit())            # False          判断zfc是否完全由数字组成

s3 = '  abcDE'
print(s3.isupper())             # False        判断字符串内字符是否全是大写

s4 = 'abcd'
print(s4.islower())              # True        判断字符串内字符是否全是小写

s5 = 'Hello Python'
print(s5.istitle())              # True       判断字符串中的单词首字母是否大写

s6 = '     '
print(s6.isspace())             # True        判断字符串是否完全由空格组成

s7 = 'hello python'
print(s7.startswith('h',2,4))    # False      判断字符串在指定范围内是否已指定字符开头
print(s7.endswith('lo',0,5))     #  True       判断字符串在指定范围内是否已指定字符结尾


s8 = 'hello python'
print(s8.split('o'))       #  ['hell', ' pyth', 'n'] 将字符串以指定内容分割，返回列表形式。

二.列表

1.列表的定义及格式：

列表是个有序的，可修改的，元素用逗号隔开，用中括号包围的序列。

格式：变量名 = [ 元素1，元素2，元素3...]

作用：存储多个数据

2.列表的索引：

通过索引获取表中的书记，索引从0开始

注意：不要索引越界

s = [ 'hello',a,b,c ]

print(s[1]) 

输出结果：a   

用for云鬟遍历列表：

name = [ 'zs','ls','ww' ]

for i in name:

      print( i )

输出结果：zs

                  ls

                  ww

3.列表的添加：append(),  insert(),  extend(), 还有两个列表直接相加

 # append 
lst = ['悟空','八戒','唐僧']       

lst.append('白骨精')      # append   向列表末尾增加指定元素

print(lst)

# 输出结果：   ['悟空', '八戒', '唐僧', '白骨精']

-------------------------------------------------------------------------------------------
 # insert 
lst = ['悟空','八戒','唐僧']

lst.insert(1,'白骨精')     # insert  往列表制定位置添加制定元素，负索引倒叙插入。超过索引插入末尾

print(lst)

# 输出结果： ['悟空', '白骨精', '八戒', '唐僧']
------------------------------------------------------------------------------------------
#extend

lst = ['悟空','八戒','唐僧']

lst1 = ['悟空','八戒','唐僧','悟空']

lst.extend(lst1)                # 将一个列表中的元素添加到另一个列表的尾部合并，不会去重。

print(lst)

# 输出结果： ['悟空', '八戒', '唐僧', '悟空', '八戒', '唐僧', '悟空']

4.列表的删除：

# pop  删除指定索引位上的元素，默认删除-1的数据

lst = ['悟空','八戒','唐僧']

lst.pop(1)

print(lst)

输出结果：['悟空', '唐僧']

lst = ['悟空','八戒','唐僧']

lst.pop()

print(lst)

输出结果：['悟空', '八戒']
-----------------------------------------------------------------------------------------
# remove 从左往右删除指定的元素，

lst = ['悟空','八戒','唐僧']

lst.remove('八戒')

print(lst)

# 输出结果：['悟空', '唐僧']
-----------------------------------------------------------------------------------------
# clear   清空列表中所有的元素，返回一个空列表

lst = ['悟空', '八戒', '唐僧']

 

lst.clear()

 

print(lst)

输出结果：[ ]
-----------------------------------------------------------------------------------------
del	删除整个列表或列表的数据，del是python内置功能，不是列表独有的


​lst = ['悟空', '八戒', '唐僧']

del lst           

print(lst)

输出结果：​​​​NameError: name 'lst' is not defined   （报错）
​

5.列表的查询：

# count 返回指定元素在列表的个数

lst  = ['hello','world','hello','python']

print(lst.count('hello'))

输出结果： 2

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

lst = ['悟空', '八戒', '唐僧', '悟空']

num1 = lst.index('悟空')

print(num1)

输出结果：0

6.列表的修改：

lst = ['悟空', '八戒', '唐僧']  

lst[0] = '白龙马'   # 将列表第一位数值为替换为‘白龙马’

print(lst)

输出结果：['白龙马', '八戒', '唐僧']

7.列表的切片：

lst = ['a', 'b', 'c', 'd', 'e']

print(lst[0:4:2])

# 输出结果为：['a', 'c']

8.列表的排序和翻转:

sort（） 按照ascii码表顺序进行排序

lst = ['tom', 'james', 'jerry', 'zs', 'ls']

lst.sort()

print(lst)  # 从小到大排序

输出结果：['james', 'jerry', 'ls', 'tom', 'zs']


lst.sort(reverse=True)  # 有大到小排序


print(lst)

输出结果：['zs', 'tom', 'ls', 'jerry', 'james']
------------------------------------------------------------------------------------
reverse()  将列表翻转

lst = ['tom', 'james', 'jerry', 'zs', 'ls']

lst.reverse()

print(lst)

输出结果：['ls', 'zs', 'jerry', 'james', 'tom']

9.列表的拷贝：

浅拷贝：

lst1 = ['西施','貂蝉',['悟空','八戒']

lst2 = lst1.copy()   #将lst1 的内容拷贝一份给lst2,  两者的id 不一样

print(lst2)

lst2[0] = '杨贵妃'   #lst2 中的西施改成杨贵妃

print(lst2)

输出结果：['西施', '貂蝉', ['悟空', '八戒']
         ['杨贵妃', '貂蝉', ['悟空', '八戒']

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

深拷贝：

import copy

lst1 = ['西施','貂蝉',['悟空','八戒']

lst2 = copy.deepcopy(lst1)

print(lst2)

lst2[0] = '杨贵妃'

print(lst2)

输出结果：['西施', '貂蝉', ['悟空', '八戒']
         ['杨贵妃', '貂蝉', ['悟空', '八戒']

三.元组

1.元组的定义及特点:

定义：

           通过()来定义：变量名=(1,2,3,4,) 。以逗号分割的，以小括号包围的序列。

           通过tuple函数定义: lst=[1,2,3,4] 变量名=tuple(lst)

特点：

            元组是有序的，不能更改的，由于元组不可变 ，所以遍历元组要比列表快。

2.元组的访问：

通过索引，默认从0开始

通过索引，默认从0开始

tup = (1,2.2,True,'hello')  #  获得2.2的值，一定要注意索引越界的问题


print(tup[1])

输出结果：2.2
-------------------------------------------------------------------------------------------
通过切片：

tup = (1,2.2,True,'hello')

print(tup[0:4:2])

输出结果：(1,True)
-----------------------------------------------------------------------------------------
访问多维元组：

tup = (('zs',10),('ls',11),('ww',12))

print(tup[1][0])

输出结果：ls

 

3.使用多个变量来接受元组的值：

tup = (('zs',10),('ls',11),('ww',12))

name,age,height,weight = ('zs',18,1.64,150)

print(name)

print(age)

print(height)

print(weight)

for name, age in tup:     #for 循环遍历多重元组

    print(name,age)



输出结果：          zs
                   18
                   1.64
                   150
                   zs 10
                   ls 11
                   ww 12

 4.元组的方法：

tup = ('a','b','c','c','b','a','x')

 

print(tup.index('b'))

 

print(tup.index('a',2,len(tup)))   

 

print(tup.count('a'))




输出结果： 1
          
          5
             
          2

5.一个逗号的魅力：

tup = (1,)

print(tup)

tup1 = (1)

print(tup1)

输出结果：（1，）

                      1

四.字典

1.字典的定义及格式：

定义：字典是一个无序的，可以修改的，元素呈键对值的形式，以逗号分隔，大括号包围的序列。

格式：变量名={key：value，key：value}

注意：字典中的key是不可变的类型，value是可变类型的

2. 字典的增加：

setdefault（）

dic = {'name': 'zs', 'age': 10, 'height': 1.75}

dic.setdefault('weight',170)   # 键存在就不添加，不存在就添加默认的值。

print(dic)

dic.setdefault('weight',180)

print(dic)

输出结果：{'name': 'zs', 'age': 10, 'height': 1.75, 'weight': 170}
         
         {'name': 'zs', 'age': 10, 'height': 1.75, 'weight': 170}


---------------------------------------------------------------------------------------
dic = {'name': 'zs', 'age': 10, 'height': 1.75}

dic['name'] = 'ww'       # 根据key键来设置值，如果key存在就直接覆盖原有的值

print(dic)


输出结果： {'name': 'ww', 'age': 10, 'height': 1.75}

3.字典的删除：

pop()

dic = {'name': 'zs', 'age': 10, 'height': 1.75}

dic.pop('name')   # 根据键删除值

print(dic)

输出结果： {'age': 10, 'height': 1.75}
------------------------------------------------------------------------------------------
popitem()

dic = {'name': 'zs', 'age': 10, 'height': 1.75}

dic.popitem()   # 随机删除一个键值对

print(dic)


输出结果：{'name': 'zs', 'age': 10}

-----------------------------------------------------------------------------------------
cleal()

dic = {'name': 'zs', 'age': 10, 'height': 1.75}

dic.clear()   #  清空字典里所有的键值对

print(dic)


输出内容：{}

del dic 

pprint（dic）

输出结果：NameError: name 'dic' is not defined  （报错）

4.字典的修改：

使用key修改：
    
 dic = {'name':'zs','age':10,'height':1.78}

 dic['name'] = '张三'

 print(dic)


输出结果： {'name':'张三','age':10,'height':1.78}

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

update（）    按照字典的格式更新键的内容，若果字典不存在这个键，就创建这个键和值

dic = {'name': 'zs', 'age': 10, 'height': 1.78}

dic1 = {'name':'张三','weight':152}

dic.update(dic1)

print(dic)


输出结果：{'name': '张三', 'age': 10, 'height': 1.78, 'weight': 152}

5.字典的查找：

c = {'name': 'zs', 'age': 10, 'height': 1.78}

print(dic.get('name'))     # get()根据键来获取相应的值，如果键不存在，默认返回None

print(dic.keys())          # 返回一个包含字典所有key的列表

print(dic.values())        # 返回一个包含字典所有value的列表

print(dic.items())         # 返回字典键值，返回呈元组的形式

print(len(dic))            # 测量字典键值对的个数，注意是键值对。




输出结果：
          zs

          dict_keys(['name', 'age', 'height'])

          dict_values(['zs', 10, 1.78])

          dict_items([('name', 'zs'), ('age', 10), ('height', 1.78)])

          3

6.for 循环及字典的遍历：

dic = {'name': 'zs', 'age': 10, 'height': 1.75}

# 获取所有的key

for key in dic:

    print(key)           

for key in dic.keys():
    
    print(key)

输出结果：
         name

         age

         height
-------------------------------------------------------------------------------------
# 获取所有的value

for value in dic.values:

    print(value)

输出结果：zs

         10

         1.75
-------------------------------------------------------------------------------------
# 获取所有的键值对，并以元组的形式返回：

for item in dic.items():
    
    print(item)


输出结果：
         ('name', 'zs')

         ('age', 10)

         ('height', 1.75)


# 字典的遍历：

for key,value in dic.items:

    print(key,value)


输出结果：

          name zs

          age 10

          height 1.75

---