python入门（3）—— python容器.字符串、列表、元组、字典

1.字符串

python中的字符串：双引号或者单引号中的数据，就是字符串
如：

# 这个是一个整型数据
a = 10
# 这是一个字符串
b = 'hello world'
# 这也是一个字符串
c = "hello world"

1.f_strings的使用

demo：

name = '狗蛋'
age = 20
print("name is " + name)
print("name is %s" % name)

# f-strings
f_strings = f"name is {name},age is {age}"
print(f_strings)
f_strings2 = f"3 + 5 = {3+5}";
print(f_strings2)

a = 10
b = 20
f_strings3 = f"a + b = {a + b}";
print(f_strings3)

结果:

2.字符串的输入

input获取的数据，都以字符串的方式进行保存，即使输入的是数字，那么也是以字符串方式保存.
demo:

 	password = input('请输入密码:')
    print("密码为：%s" % password)

结果：

	 请输入密码:haohaoxuexitiantianxiangshang
     密码为： haohaoxuexitiantianxiangshang

3.字符串的下标操作

列表与元组支持下标索引好理解，字符串实际上就是字符的数组，所以也支持下标索引。

如果有字符串:name = 'abcdef'，在内存中的实际存储如下:

1.索引基本使用

s = "hello python"
# 打印字符串中的第一个元素
print(s[0])
# 得到字符串的长度
print(len(s))
# 打印字符串中最后一个元素
print(s[len(s) - 1])

输出:

h
12
n

2.遍历字符串

s = "this is a wonderful world"
# 遍历字符串方法1：使用while
i = 0
while i < len(s):
    print(s[i],end="")
    i += 1

print()
print("==========================")

# 方法2：使用for循环遍历
for x in s:
    print(x,end="")

输出：

this is a wonderful world
==========================
this is a wonderful world

3.for-else的使用

s = "hello world"
for x in s :
    if x == "r":
        print("该字符串包含r字母，终止一下")
        break
else:
    print("该字符串没有含有r字母")

输出:

该字符串包含r字母，终止一下

4.字符串切片的使用（截取字符串）

切片的语法：[起始:结束] (左闭右开)

"""
字符串切片的基本使用
    就是截取字符串

    切片的格式:
        字符串名[开始索引: 结束索引]

        从 开始索引 对应的元素截取, 一直截取到 结束索引 对应的元素.
        包含 开始索引 对应的元素, 不包含 结束索引 对应的元素
"""
s = "hello python"

print(len(s)) # 12
# 从第一个字母截取到最后一个字母
print(s[0:12])
# 截取中间的一段
print(s[1:11]) # ello pytho
print(s[1:12]) # ello python

# 如果是截取到最后的那个元素，后边的那个索引可以不用写的
print(s[1:]) # ello python

# 如果截取的是从头开始的，第一个索引可以不用写出来的
print(s[:11]) # hello pytho

# 如果右边的索引越界了会默认为就是截取到最后的那个元素
print(s[0:111]) # hello python

# 如果截取的索引是负数，默认就是从右边开始
print(s[-11:-1]) # ello pytho
print(s[-12:-1]) # hello pytho

print(s[3:-2]) # lo pyth

print(s[:-11])

5.带步长的字符串切片（有翻转方法介绍）

切片的语法：[起始:结束:步长]
注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔。

"""
字符串切片步长的格式:
    字符串名[开始索引: 结束索引: 步长]

    假如步长是n.
    从开始索引对应的元素 截取,一直截取到 结束索引 对应的元素.
    先 截取出  开始索引对应的元素, 然后每次都是向后数n个元素,第n个元素是谁就把谁截出来.
    最后按照截取的先后顺序,组成一个字符串. 这个字符串 就是截取的结果.
"""
s = "hello python"
# 默认的步长是1
print(s[1:11]) # ello pytho
print(s[1:11:1]) # ello pytho
# 改变步长看结果
print(s[1:11:2]) # el yh

# 步长可以为负数，表示倒序取
print(s[11:1:-2]) # nhy l 第一个索引表示右边开始的第一个索引，第二个为左边开始的索引,-2为倒序并且间隔1个元素来取

print(s[-1:1:-2]) # nhy l

# 字符串翻转操作,就是直接将步长设置为-1就行了
print(s[::-1]) # nohtyp olleh

6.字符串常用的方法——查找、统计、分割

s1 = "hello python"

print("=========find==============")

# 查找功能练习
print(s1.find("p")) # 6 查找p字母在字符串中第一次出现的位置
print(s1.find("p", 3, 6)) # -1 在s1的索引为3-6的区间内查找h字母的位置，找不到的返回-1
print(s1.find("p", 3, 7)) # 6 返回的是在原字符串中的索引位置

print(s1.find("pyt")) # 6 寻找该字符串在原字符串中第一次出现的索引
print(s1.find("pyx")) # -1 没有这个子字符串，返回-1
print(s1.index("pyt")) # 6

print(s1.rfind("pyt")) # 6 从右边开始查找第一次出现pyt的索引

ss = "hello pythonpyt"
print(ss.rfind("pyt")) # 对比上边的可以看出来，确实就是从右边来搜索的

# 统计功能的练习
print("============count==================")
print(s1.count("o")) # 2
print(s1.count("o",5,11)) # 1

# 分割方法的练习
print("==============split====================")
s2 = "hello python android"
# 分割的结果是一个列表, 把分割出来的几部分字符串作为元素放到列表中了
list1 = s2.split(" ")
print(list1) # ['hello', 'python', 'android']
print(type(list1)) # <class 'list'>

# 这个方法只能分割出3部分: 左边部分,自己,右边部分
list2 = s2.partition(" ")
print(list2) # ('hello', ' ', 'python android')
print(type(list2)) # <class 'tuple'>

7.字符串常用方法——判断（包含子串、大小写）

# 1.判断字符串是否都由字母组成
s1 = "asdsafda"
print(s1.isalpha()) # True
# 2.判断字符串是否都是由数字组成的
s2 = "123456"
print(s2.isdigit()) # True
print(s2.isdecimal()) # True

# 3.判断字符串是否都是大写的或者都是小写的
s3 = "LED123AAA"
print(s3.isupper()) # True
s4 = "led111aaa"
print(s4.islower()) # True

# 4. 判断字符串是否以另外的一个字符串作为开头或者结尾
s5 = "hello fafa mama"
print(s5.startswith("hello")) # True
print(s5.startswith("h")) # True

print(s5.endswith("mama")) # True
print(s5.endswith("a")) # True

8.字符串常用方法——大小写转换、替换、去空格、对齐

# 1.替换的方法: s1.replace(oldstr, newstr)
s1 = "hello world python"
s2 = s1.replace("python", "java") # 下边两种写法的结果是一样的
# s2 = s1.replace("python", "java", 10)
# s2 = s1.replace("python", "java", 1)
print(s2) # hello world java

# 2.大小写转换的方法:
s3 = "hello 123 PyThon"
print(s3.lower()) # hello 123 python
print(s3.upper()) # HELLO 123 PYTHON

# 3.去掉空格:(strip去掉的是首尾的空格，replace去掉所有的空格)
print("========去掉空格===========")
s4 = " hello python "
print("a" + s4.strip() + "b") # ahello pythonb
print("a" + s4.strip() + "b") # ahello pythonb
print(s4.replace(" ", "")) # hellopython

# 4.对齐方法
# center:返回一个原字符串居中,并使用空格填充至长度 width 的新字符串
print("======对齐方法=======")
s5 = "hello"
print(s5) # hello
print(s5.ljust(15)) # hello          一直到这里都是空白
print(s5.rjust(15)) #           hello
print(s5.center(15)) #     hello     

# join
s6 = "hello"
s7 = "python"
# 使用s6连接s7中的元素,得到一个新的字符串
result = s6.join(s7)
print(result) # phelloyhellothellohhelloohellon 在python的每个字母间插入字符串s7
print(type(result)) # class 'str'>

2. 常用函数——f-strings简化字符串格式化

demo:

name = '狗蛋'
age = 20
print("name is " + name)
print("name is %s" % name)

#
f_strings = f"name is {name},age is {age}"
print(f_strings)
f_strings2 = f"3 + 5 = {3+5}";
print(f_strings2)

a = 10
b = 20
f_strings3 = f"a + b = {a + b}";
print(f_strings3)

输出结果：

name is 狗蛋
name is 狗蛋
name is 狗蛋,age is 20
3 + 5 = 8
a + b = 30

3. 列表的使用

比C语言的数组强大的地方在于列表中的元素可以是不同类型的

testList = [1, ‘a’]

5.1基本使用：

"""
列表:
    也是一个容器,可以存储多个元素,元素可以是任何类型的.

定义格式:
    # 非空
    列表名 = [元素1, 元素2, ...]
    # 空列表
    列表名 = []
"""
name_list = ["vivi","爽儿", "千寻","冬冬", "冰冰", "圆圆"]
print(name_list) # ['vivi', '爽儿', '千寻', '冬冬', '冰冰', '圆圆']
print(type(name_list)) # <class 'list'>

list1 = [10, 3.14, "hello", True] # 放什么元素都行的
print(list1) # [10, 3.14, 'hello', True]

# 定义空列表
list2 = []
print(list2) # []

5.2 增删改查操作

list1 = ["大双", "小双", "建宁"]
print(list1) # ['大双', '小双', '建宁']

# 1.向列表中添加一个元素
# append(数据):在列表的最后添加一个元素
list1.append("龙儿")
print(list1) # ['大双', '小双', '建宁', '龙儿']

# 2.在指定的索引处插入一个元素
list1.insert(2, "小宝")
print(list1) # ['大双', '小双', '小宝', '建宁', '龙儿']

# 3.继承:把另外一个容器中的元素添加自己的容器中
list_age = [18, 19, 20]
list1.extend(list_age) #
print(list1) # ['大双', '小双', '小宝', '建宁', '龙儿', 18, 19, 20]

list1.extend("hello")
print(list1) # ['大双', '小双', '小宝', '建宁', '龙儿', 18, 19, 20, 'h', 'e', 'l', 'l', 'o']

# 4.修改
list2 = [10, 20, "Hello", True]
print(list2[2]) # Hello
list2[2] = "vivi"
print(list2) # [10, 20, 'vivi', True]

# 5.删除元素
# 删除指定位置的元素
list2.remove("vivi")
print(list2) # [10, 20, True]

# 删除指定索引处的元素,返回被删除的元素
result = list2.pop(2)
print(result) # True
print(list2) # [10, 20]

# pop方法中没有写索引,默认删除最后一个元素
list2.pop()
print(list2) # [10]

list1.append("python")
print(list1) #  [10, "python"]
list1.pop()
print(list1) # [10]

# 把列表中的元素全部删除,清空
list1.clear()
print(list1) # []

5.3 列表的遍历操作

list1 = [10, 20, 30]
# 方式一:while循环语句
# 作为元素的索引
i = 0
while i < 3:
    print(list1[i])
    i += 1

print("==========================")

# 方式二: for循环遍历
for e in list1:
    print(e)

5.4 列表的嵌套

# 如果列表中的元素还是一个列表,你的列表就是嵌套的列表.
name_list = [["孙俪", "谢娜", "贾玲"], ["蓉蓉", "百合", "露露"]]

print(name_list[0][0])
print(name_list[0][1])
print(name_list[0][2])

print(name_list[1]) # ["蓉蓉", "百合", "露露"]

# list2 = name_list[1] # ;list2 = ["蓉蓉", "百合", "露露"]
# print(list2[0])
# print(list2[1])
# print(list2[2])

print(name_list[1][0])
print(name_list[1][1])
print(name_list[1][2])

# 遍历嵌套的列表
for list in name_list:
    print(list)
    for e in list:
        print(e)
'''
孙俪
谢娜
贾玲
['蓉蓉', '百合', '露露']
蓉蓉
百合
露露
'''

5.5 列表的排序

"""
排序:
    可以按照升序/降序排序.
"""
list1 = [1, 5, 2, 8, 6, 4]

# 默认是按照升序排列的
list1.sort()
print(list1) # [1, 2, 4, 5, 6, 8]

# 倒序排序
list1.sort(reverse=True)
print(list1) # [8, 6, 5, 4, 2, 1]

list2 = ["java", "python", "C++", "Php", "中国"]
list2.sort()
print(list2)  # ['C++', 'Php', 'java', 'python', '中国'] 按照ASCII

print(ord("中")) # 20013 返回对应的 ASCII 数值

4.元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

>>> aTuple = ('et',77,99.9)
>>> aTuple
('et',77,99.9)

<1>访问元组

<2>修改元组

说明： python中不允许修改元组的数据，包括不能删除其中的元素。

<3>count, index

index和count与字符串和列表中的用法相同

>>> a = ('a', 'b', 'c', 'a', 'b')
>>> a.index('a', 1, 3) # 注意是左闭右开区间
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>> a.index('a', 1, 4)
3
>>> a.count('b')
2
>>> a.count('d')
0

5.字典介绍

变量info为字典类型：

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}

说明：

• 字典和列表一样，也能够存储多个数据
• 列表中找某个元素时，是根据下标进行的
• 字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值，例如上面代码中的’name’、‘id’、‘sex’）
• 字典的每个元素由2部分组成，键:值。例如 ‘name’:‘班长’ ,'name’为键，'班长’为值

5.1 字典取值（查看）：

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
print(info["name"]) # 班长
print(info["sex"]) # f
# print(info["aa"])
print(info.get("aa")) # None
print(info.get("name")) # 班长

5.2 修改元素

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

  info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}

    newId = input('请输入新的学号')

    info['id'] = int(newId)

    print('修改之后的id为%d:'%info['id'])

输出:

5.3添加元素

info = {'name':'班长', 'id':100, 'sex':'f', 'address':'地球亚洲中国北京'}
print(info["name"]) # 班长

# 添加元素
info["aa"] = 1111
print(info) # {'name': '班长', 'id': 100, 'sex': 'f', 'address': '地球亚洲中国北京', 'aa': 1111}

输出：

5.4 删除元素

对字典进行删除操作，有一下几种：

• del
• clear()
  demo:del删除指定的元素

    info = {'name':'班长', 'sex':'f', 'address':'地球亚洲中国北京'}

    print('删除前,%s'%info['name'])

    del info['name']

    print('删除后,%s'%info['name'])

输出：

demo: del 删除整个字典

    info = {'name':'monitor', 'sex':'f', 'address':'China'}

    print('删除前,%s'%info)

    del info

    print('删除后,%s'%info)

输出：

demo:clear清空整个字典

    info = {'name':'monitor', 'sex':'f', 'address':'China'}

    print('清空前,%s'%info)

    info.clear()

    print('清空后,%s'%info)

5.5 字典中常用的方法(keys/values/items)

5.6 字典的遍历

5.7 有序字典:OrderDcit（py3.6以上不用考虑了）

我们先看一段代码, 此代码运行在 Python3.5 版本中:

# 创建无序字典
my_dict = dict()
# 向字典中添加元素
my_dict['one'] = 1
my_dict['two'] = 2
my_dict['three'] = 3
my_dict['four'] = 4
print(my_dict)

输出结果(不固定):

{'three': 3, 'two': 2, 'four': 4, 'one': 1}

输出结果并不是按照我们创建字典、添加元素的顺序输出, 这是由于 dict 是无序的. 如果我们想最终打印输出的顺序和我们操作时的顺序保持一致, 我们就需要使用有序字典:

from collections import OrderedDict

# 创建有序字典
my_dict = OrderedDict()
# 向字典中添加元素
my_dict['one'] = 1
my_dict['two'] = 2
my_dict['three'] = 3
my_dict['four'] = 4
print(my_dict)

输出结果:

OrderedDict([('one', 1), ('two', 2), ('three', 3), ('four', 4)])

在 Python3.6 版本中, dict 字典已经经过优化, 变为有序字典. 并且字典所占用的内存占用减少了20％到25％.

第一段代码在 Python3.6 运行下, 输出结果如下:

{'one': 1, 'two': 2, 'three': 3, 'four': 4}

6.公共方法

6.1运算符

+

>>> "hello " + "itcast"
'hello itcast'
>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> ('a', 'b') + ('c', 'd')
('a', 'b', 'c', 'd')

*

>>> 'ab' * 4
'ababab'
>>> [1, 2] * 4
[1, 2, 1, 2, 1, 2, 1, 2]
>>> ('a', 'b') * 4
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')

in

>>> 'itc' in 'hello itcast'
True
>>> 3 in [1, 2]
False
>>> 4 in (1, 2, 3, 4)
True
>>> "name" in {"name":"Delron", "age":24}
True

注意，in在对字典操作时，判断的是字典的键

6.2 python内置函数

Python包含了以下内置函数