【python】零基础入门（1/3）：字符串 || 运算 || 列表 || 字典

pip list  # 查看pip下有哪些模块
pip install selenium  # 安装selenium
pip install -U selenium  # 升级selenium到最新版
pip uninstall selenium  # 卸载selenium

words = 'Hello World!'
print(words.find('World'))  # 查询'World'在字符串中第一次出现的索引位置，如果未找到就返回-1
print(words.replace('World', 'WelYan'))  # 将字符串中'World'替换成'WelYan'

6
Hello WelYan!

words = 'Hello World!' 
print(words.split('l'))  # 以'l'为分隔符，拆分字符串存入一个列表，返回列表，不传默认为空格 
print('l'.join(['He', '', 'o Wor', 'd!']))  # 以'l'为连接，把列表中元素连接为一个字符串 
print('Hello ' + 'World' + '!')  # 使用 + 号拼接字符串，需要自己设定好空格 
print('Hello', 'World', '!')  # 使用英文逗号直接隔开，仅限于print()中使用，会自动插入空格

['Hello', 'World!']
Hello World!
Hello World!
Hello World !

words = 'Hello World!'
print(words.lower())  # 将字符串转为小写
print(words.upper())  # 将字符串转为大写
print(words.capitalize())  # 将字符串首字母大写
print(words.title())  # 将每个单词首字符大写

hello world!
HELLO WORLD!
Hello world!
Hello World!

words = 'Hello World!'
print(words.strip('H'))  # 去除字符串开头和结尾的'H'，不传默认为去除空白
print(words.lstrip('H'))  # 去除字符串开头的'H'，不传默认为去除空白
print(words.rstrip('H'))  # 去除字符串结尾的'H'，不传默认为去除空白
print(words.center(20, '*'))  # 返回指定长度的字符串，以原字符串居中，以'*'填充首尾
print(words.ljust(20, '*'))  # 返回指定长度的字符串，以原字符串左对齐，以'*'填充首尾
print(words.rjust(20, '*'))  # 返回指定长度的字符串，以原字符串右对齐，以'*'填充首尾

ello World!
ello World!
Hello World!
****Hello World!****
Hello World!********
********Hello World!

words = 'hello world!'
print('以H开头: ', words.startswith('h'))  # 判断字符串是否以'H'开头
print('以H结尾：', words.endswith('h'))  # 判断字符串是否以'H'结尾
print('只包含字母和数字：', words.isalnum())  # 判断字符串是否只包含字母和数字
print('只包含字母：', words.isalpha())  # 判断字符串是否只包含字母
print('只包含数字：', words.isdigit())  # 判断字符串是否只包含数字
print('全部为小写：', words.islower())  # 判断字符串是否全部为小写
print('全部为大写：', words.isupper())  # 判断字符串是否全部为大写
print('只包含空白字符：', words.isspace())  # 判断字符串是否只包含空白字符

以H开头:  True
以H结尾： False
只包含字母和数字： False
只包含字母： False
只包含数字： False
全部为小写： True
全部为大写： False
只包含空白字符： False

name = 'Weiyan'
age = 17
print('name: {}, age: {}'.format(name, age))  # 格式化字符串的一种方式
print(f'name: {name}, age: {age}')  # 格式化字符串的一种方式
print('name: %s, age: %d' % (name, age))  # 格式化字符串的一种方式

name: Weiyan, age: 17
name: Weiyan, age: 17
name: Weiyan, age: 17

words = input('输入字符串：')  # 获取用户输入字符串
print(id(words))
print(type(words))  # 通过type查对象元素类型
print(words.count('l'))  # 字符'l'在字符串中出现的次数
print(len(words))  # 字符串的长度

输入字符串：Hello, I'm Weiyan
2162362581520
<class 'str'>
2
17

a = 2
b = 5
print('a + b =', a + b)  # 加法，7
print('a - b =', a - b)  # 减法，-3
print('a * b =', a * b)  # 乘法，10
print('a / b =', a / b)  # 除法，0.4
print('b // a =', b // a)  # 整除，2
print('b % a =', b % a)  # 取余，1
print('a ** b =', a ** b)  # 幂运算，32

a + b = 7
a - b = -3
a * b = 10
a / b = 0.4
b // a = 2
b % a = 1
a ** b = 32

a = 2
b = 5
print('a == b：', a == b)  # 等于，False
print('a != b：', a != b)  # 不等于，True
print('a > b：', a > b)  # 大于，False
print('a < b：', a < b)  # 小于，True
print('a >= b：', a >= b)  # 大于等于，False
print('a <= b：', a <= b)  # 小于等于，True

a == b： False
a != b： True
a > b： False
a < b： True
a >= b： False
a <= b： True

T = True
F = False
print('T and F：', T and F)  # 与，False
print('T or F：', T or F)  # 或，True
print('not T：', not T)  # 非，False

T and F： False
T or F： True
not T： False

a = 2  # 简单的赋值
a += 1  # 增强赋值，等同于a = a + 1，结果a = 3
b = c = 7  # 链式赋值
d, e = 8, 9  # 多重赋值，可以一次按顺序对多个不同变量，赋值多个不同值
print('a：', a)
print('b, c：', str(b), str(c))
print('d, e：', str(d), str(e))

a： 3
b, c： 7 7
d, e： 8 9

words = 'hello world!'
print('l' in words)  # 判断'l'是否在字符串中，True
print('l' not in words)  # 判断'l'是否不在字符串中， False

True
False

a = ['1', '2', '3', '2', '1']
b = ['1', '2', '3', '2', '1']
print(a is b)  # 判断两个变量是否引用同一个对象，False（）
print(a is not b)  # 判断两个变量是否引用同一个对象，True

False
True

l_empty = []  # 创建空列表
l_alpha = ['a', 'b', 'c']  # 创建列表
l_empty1 = list()
l_numbers = list(range(1, 6))  # 使用range()和list()创建数字列表
l_squares = [i**2 for i in range(1, 6)]  # 使用推导式创建列表
print('l_empty：', l_empty)
print('l_alpha：', l_alpha)
print('l_empty1：', l_empty1)
print('l_numbers：', l_numbers)
print('l_squares：', l_squares)

l_empty： []
l_alpha： ['a', 'b', 'c']
l_empty1： []
l_numbers： [1, 2, 3, 4, 5]
l_squares： [1, 4, 9, 16, 25]

alpha = ['z', 'b']
l_alpha.append('c')  # 在列表末尾添加一个元素
l_alpha.insert(3, 'd')  # 在指定索引位置插入一个元素
l_alpha.extend(['e', 'f'])  # 在列表末尾扩展添加一个列表
l_alpha[0] = 'a'  # 根据索引修改列表中元素
print(l_alpha)

['a', 'b', 'c', 'd', 'e', 'f']

l_alpha = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
l_alpha.pop(-1)  # 删除列表中指定索引位置的元素，不传则默认为最后一个元素。此次删掉了'g'
a = l_alpha.pop()  # 通过pop()删除的元素可以赋值给变量。此次删掉了'f'
print(a)

l_alpha.remove('e')  # 删除列表中第一个匹配的元素。此次删掉了'e'
del(l_alpha[0])  # 根据索引删除列表中第一个元素。此次删掉了'a'
print(l_alpha)

l_alpha.clear()  # 清空列表
print(l_alpha)

f
['b', 'c', 'd']
[]

l_alpha = ['a', 'b', 'c', 'b']
first = l_alpha[0]  # 根据索引获取列表中第一个元素
last = l_alpha[-1]  # 根据索引获取列表中最后一个元素
index = l_alpha.index('b')  # 查询字符'c'第一次出现的索引
count = l_alpha.count('b')  # 查询字符'c'在列表中出现的次数
print('first：', first)
print('last：', last)
print('index：', index)
print('count：', count)

first： a
last： b
index： 1
count： 2

l_alpha = ['a', 'b', 'c', 'b']
l_alpha.sort(reverse=True)  # 对列表中元素进行排序，reverse=True为反序，为False或者不传为正序
print('sort()原表：', l_alpha)

l_sorted = sorted(l_alpha, reverse=False)  # 将列表临时排序后赋值给新变量，reverse=True为反序，False或不传为正序
print('sorted()原表：', l_alpha)
print('sorted()新表：', l_sorted)

l_alpha.reverse()  # 对列表进行首尾反转
print('reverse()原表：', l_alpha)

sort()原表： ['c', 'b', 'b', 'a']
sorted()原表： ['c', 'b', 'b', 'a']
sorted()新表： ['a', 'b', 'b', 'c']
reverse()原表： ['a', 'b', 'b', 'c']

l_alpha = ['a', 'b', 'c', 'b', 'e']
l_slice1 = l_alpha[0:3]  # 切片，获取子列表包含元素索引0开始，2结尾
l_slice2 = l_alpha[:3]  # 切片，获取子列表包含元素索引0开始，2结尾
l_slice3 = l_alpha[-2:]  # 切片，获取子列表包含元素索引-2开始，-1结尾
l_slice4 = l_alpha[::2]  # 切片，获取子列表包含元素索引0开始，-1结尾，每隔一个元素取一个
l_slice5 = l_alpha[:]  # 切片，获取子列表包含元素索引0开始，-1结尾，相当于复制了列表
print('原表：', l_alpha)
print('l_alpha[0:3]：', l_slice1)
print('l_alpha[:3]：', l_slice2)
print('l_alpha[-2:]：', l_slice3)
print('l_alpha[::2]：', l_slice4)
print('l_alpha[:]：', l_slice5)

原表： ['a', 'b', 'c', 'b', 'e']
l_alpha[0:3]： ['a', 'b', 'c']
l_alpha[:3]： ['a', 'b', 'c']
l_alpha[-2:]： ['b', 'e']
l_alpha[::2]： ['a', 'c', 'e']
l_alpha[:]： ['a', 'b', 'c', 'b', 'e']

l_alpha = ['a', 'b', 'c', ['d', 'e']]
l_copy1 = l_alpha.copy()  # 浅拷贝
l_copy2 = l_alpha[:]  # 浅拷贝
import copy
l_copy3 = copy.copy(l_alpha)  # 浅拷贝
l_copy4 = copy.deepcopy(l_alpha)  # 深拷贝
print(l_copy1)
print(l_copy2)
print(l_copy3)
print(l_copy4)

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

l_nums = [1, 2, 4, 3, 2, 1]
l_len = len(l_nums)  # 查询列表长度
l_min = min(l_nums)  # 查询列表中最小值
l_max = max(l_nums)  # 查询列表中最大值
l_sum = sum(l_nums)  # 查询列表在所有元素的和
print('l_len：', l_len)
print('l_min：', l_min)
print('l_max：', l_max)
print('l_sum：', l_sum)

l_len： 6
l_min： 1
l_max： 4
l_sum： 13

nums = (1, 2, 3, 4)  # 创建一个元组。

d_empty1 = {}  # 使用花括号创建空字典
d_infor1 = {'name': 'Weiyan', 'age': 17}  # 使用花括号创建字典
d_empty2 = dict()  # 使用dict()函数创建空字典
d_infor2 = dict(name='Weiyan', age=17)  # 使用dict()函数和关键字参数创建字典
d_infor3 = dict([('name', 'Weiyan'), ('age', 17)])  # 使用dict()函数和键值对列表创建字典
print(d_empty1)
print(d_infor1)
print(d_empty2)
print(d_infor2)
print(d_infor3)

{}
{'name': 'Weiyan', 'age': 17}
{}
{'name': 'Weiyan', 'age': 17}
{'name': 'Weiyan', 'age': 17}

d_infor = {'name': 'Weiyan', 'age': 17}
d_infor['city'] = 'Shenzhen'  # 如果字典中已存在键city，就修改值，如果不存在，就新增键值对
print(d_infor)

d_infor.update({'sex': 'male', 'age': 16})  # 使用update()方法更新字典，更新后字典内存地址不变
print(d_infor)

{'name': 'Weiyan', 'age': 17, 'city': 'Shenzhen'}
{'name': 'Weiyan', 'age': 16, 'city': 'Shenzhen', 'sex': 'male'}

d_infor = {'name': 'Weiyan', 'age': 17, 'city': 'Shenzhen'}
del(d_infor['city'])  # 使用del删除键值对
num = d_infor.pop('age')  # 使用pop()删除键值对
print(d_infor)

d_infor.clear()  # 使用clear()情况字典
print(d_infor)

{'name': 'Weiyan'}
{}

d_infor = {'name': 'Weiyan', 'age': 17}
name = d_infor['name']  # 根据键获取字典中的值
age = d_infor.get('age', 'hello')  # 使用get()方法获取字典中的值
keys = d_infor.keys()  # 获取字典中所有键
values = d_infor.values()  # 获取字典中所有值
items = d_infor.items()  # 获取字典中所有键值对
print('name：', name)
print('age：', age)
print('age：', keys)
print('values：', values)
print('items：', items)

name： Weiyan
age： 17
age： dict_keys(['name', 'age'])
values： dict_values(['Weiyan', 17])
items： dict_items([('name', 'Weiyan'), ('age', 17)])

d_infor = {'name': 'Weiyan', 'age': 17, 'city': {'city1': 'JingDeZhen', 'city2': 'ShenZhen'}}
d_copy1 = d_infor.copy()  # 浅拷贝
import copy
d_copy2 = copy.copy(d_infor)  # 浅拷贝
d_copy3 = copy.deepcopy(d_infor)  # 深拷贝
print('d_copy1：', d_copy1)
print('d_copy2：', d_copy2)
print('d_copy3：', d_copy3)

d_copy1： {'name': 'Weiyan', 'age': 17, 'city': {'city1': 'JingDeZhen', 'city2': 'ShenZhen'}}
d_copy2： {'name': 'Weiyan', 'age': 17, 'city': {'city1': 'JingDeZhen', 'city2': 'ShenZhen'}}
d_copy3： {'name': 'Weiyan', 'age': 17, 'city': {'city1': 'JingDeZhen', 'city2': 'ShenZhen'}}

d_infor = {'name': 'Weiyan', 'age': 17, 'city': 'ShenZhen'}
print('keys：')
for key in d_infor.keys():  # 遍历字典中的键
    print(key)

print('\nvalues：')
for value in d_infor.values():  # 遍历字典中的值
    print(value)

print('\nkeys，values：')
for key, value in d_infor.items():  # 遍历字典中的键值对
    print(f'{key}: {value}')

keys：
name
age
city

values：
Weiyan
17
ShenZhen

keys，values：
name: Weiyan
age: 17
city: ShenZhen

d_infor = {'name': 'Weiyan', 'age': 17, 'city': 'ShenZhen'}
print(len(d_infor))  # 获取字典的长度
print('name' in d_infor)  # 检查字典中是否有该键

print('\nsorted_keys：')
for key in sorted(d_infor.keys()):  # 按字符排序遍历字典中所有键
    print(key)

3
True

sorted_keys：
age
city
name