python 字典元组集合字符串

s1 = ''hello, world!''
s2 = ' hello, world!\n'
print(s1, s2, end='')

s1 = '141142143x61x62x63'
s2 = 'u9a86u660a'
print(s1, s2)

s1 = r''hello, world!''
s2 = r' hello, world!\n'
print(s1, s2, end='')
print(' ')
print('-----------------------------')
s1 = 'hello ' * 3
print(s1) # hello hello hello

拼接字符串

s2 = 'world'
s1 += s2
print(s1) # hello hello hello world
print('ll' in s1) # True
print('wor' in s1)
str2 = 'abc123456'

从字符串中取出指定位置的字符(下标运算)

print(str2[2]) # c
print(str2[2:5]) # c12
print(str2[2:]) # c123456
print(str2[2::2]) # c246
print(str2[::2]) # ac246
print(str2[::-1]) # 654321cba
print(str2[-3:-1]) # 45
str1 = 'hello, world!'

通过内置函数len计算字符串的长度

print(len(str1)) # 13

获得字符串首字母大写的拷贝

print(str1.capitalize()) # Hello, world!

获得字符串每个单词首字母大写的拷贝

print(str1.title()) # Hello, World!

获得字符串变大写后的拷贝

print(str1.upper()) # HELLO, WORLD!

从字符串中查找子串所在位置

print(str1.find('or')) # 8
print(str1.find('shit')) # -1

与find类似但找不到子串时会引发异常

print(str1.index('or'))

print(str1.index('shit'))

检查字符串是否以指定的字符串开头

print(str1.startswith('He')) # False
print(str1.startswith('hel')) # True

检查字符串是否以指定的字符串结尾

print(str1.endswith('!')) # True

将字符串以指定的宽度居中并在两侧填充指定的字符

print(str1.center(50, '*'))

将字符串以指定的宽度靠右放置左侧填充指定的字符

print(str1.rjust(50, ' '))
str2 = 'abc123456'

检查字符串是否由数字构成

print(str2.isdigit()) # False

检查字符串是否以字母构成

print(str2.isalpha()) # False

检查字符串是否以数字和字母构成

print(str2.isalnum()) # True
str3 = ' jackfrued@126.com '
print(str3)

获得字符串修剪左右两侧空格之后的拷贝

print(str3.strip())

a, b = 5, 10
print('%d * %d = %d' % (a, b, a * b))

a, b = 5, 10
print('{0} * {1} = {2}'.format(a, b, a * b))

a, b = 5, 10
print(f'{a} * {b} = {a * b}')
list1 = [1, 3, 5, 7, 100]
print(list1) # [1, 3, 5, 7, 100]

乘号表示列表元素的重复

list2 = ['hello'] * 3
print(list2) # ['hello', 'hello', 'hello']

计算列表长度(元素个数)

print(len(list1)) # 5

下标(索引)运算

print(list1[0]) # 1
print(list1[4]) # 100

print(list1[5]) # IndexError: list index out of range

print(list1[-1]) # 100
print(list1[-3]) # 5
list1[2] = 300
print(list1) # [1, 3, 300, 7, 100]

通过循环用下标遍历列表元素

for index in range(len(list1)):
print(list1[index])

通过for循环遍历列表元素

for elem in list1:
print(elem)

通过enumerate函数处理列表之后再遍历可以同时获得元素索引和值

for index, elem in enumerate(list1):
print(index, elem)

print('-----------------------------')

如何向列表中添加元素以及如何从列表中移除元素

list3 = [1, 3, 5, 7, 100, 200]

添加元素

print(list3)
list3.insert(1, 400)
print(list3)

合并两个列表

list3 += [1000, 2000]
print(list3)

先通过成员运算判断元素是否在列表中，如果存在则删除元素

if 3 in list3:
list3.remove(3)
if 1234 in list3:
list3.remove(1234)
print(list3)

从指定位置删除元素

list3.pop(0)
list3.pop(len(list3)-1)
print(list3)

import sys

列表也可以做切片操作，通过切片操作我们可以实现对列表的复制或者将列表中的一部分取出来创建出新的列表，

fruits = ['grape', 'apple', 'strawberry', 'waxberry']
fruits += ['pitaya', 'pear', 'mango']
print(fruits)

列表切片

fruits2 = fruits[1:4] # 'apple', 'strawberry', 'waxberry'
print(fruits2)

可以通过完整切片操作来复制列表

fruits3 = fruits[:]
print(fruits3)

可以通过反向切片操作来获得倒转后的列表的拷贝

fruits5 = fruits[::-1]
print(fruits5)
print('---------------排序-----------------------')
list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
list2 = sorted(list1)

sorted函数返回列表排序后的拷贝不会修改传入的列表

函数的设计就应该像sorted函数一样尽可能不产生副作用

list3 = sorted(list1, reverse=True)

通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序

list4 = sorted(list1, key=len)
print(list1)
print(list2)
print(list3)
print(list4)

给列表对象发出排序消息直接在列表对象上进行排序

list1.sort(reverse=True)
print(list1)

使用列表的生成式语法来创建列表

f = [x for x in range(1, 10)]
print(f)
f = [x + y for x in 'ABCDE' for y in '1234567']
print(f)

f = [x ** 2 for x in range(1, 1000)]
print(sys.getsizeof(f)) # 查看对象占用内存的字节数
print(f)

请注意下面的代码创建的不是一个列表而是一个生成器对象

通过生成器可以获取到数据但它不占用额外的空间存储数据

每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)

f = (x ** 2 for x in range(1, 1000))
print(sys.getsizeof(f)) # 相比生成式生成器不占用存储数据的空间
print(f)
for val in f:
print(val)

列表解析：根据已有列表，高效创建新列表的方式。

列表解析是Python迭代机制的一种应用，它常用于实现创建新的列表，因此用在[]中。

语法：

[expression for iter_val in iterable]

[expression for iter_val in iterable if cond_expr]

1. 要求：列出1-10所有的数字之和的平方

1. 直接的方法：

l = []
for i in range(1, 11):
l.append(i ** 2)
print(l)

2. 使用列表解析

l = [i ** 2 for i in range(1, 11)]
print(l)

2. 要求：列出1~10中大于等于4的数字的平方

2.1.1：使用普通方法：

for i in range(1, 11):
if i > 4:
print(i ** 2)

2.1.2 ： 使用列表：

l = []
for i in range(1, 11):
if i > 4:
l.append(i ** 2)
print(l)

使用列表解析：

[expression for iter_val in iterable if cond_expr]

l = [i ** 2 for i in range(1, 11) if i > 4]
print(l)

补充：

f = [x + y for x in 'ABCDE' for y in '1234567']
print(f)
test = []
for x in 'ABCDE':
for y in '1234567':
test.append(x+y)
print(test)

使用集合

创建集合的字面量语言

set1 = {1, 2, 3, 3, 3, 2}
print(set1)
print('Length:', len(set1))

创建集合的构造器语法

set2 = set(range(1, 10))
set3 = set((1, 2, 3, 3, 2, 1))
print(set2, set3)

创建集合的推导式语法(推导式也可以用于推导集合)

set4 = {num for num in range(1, 100) if num % 3 == 0 or num % 5 == 0}
print('set4:', set4)
set5 = {1}
for num in range(1, 100):
if num % 3 == 0 or num % 5 == 0:
set5.add(num)
set5.remove(1)
print('set5', set5)

添加元素 删除元素

set1.add(4)
print(set1)
set2.update([11, 12])
print(set2)
set2.discard(5)
print(set2)
if 4 in set2:
set2.remove(4)
print(set2)

集合的成员、交集、并集、差集等运算

print('操作前的集合：')
print('set1:', set1)
print('set2:', set2)

交集：

print(set1 & set2)
print(set1.intersection(set2))

并集

print(set1 | set2)

print(set1.union(set2))

差集

print(set1 - set2)

print(set1.difference(set2))

判断子集和超集

print(set2 <= set1)

print(set2.issubset(set1))

print(set3 <= set1)

print(set3.issubset(set1))

print(set1 >= set2)

print(set1.issuperset(set2))

print(set1 >= set3)

print(set1.issuperset(set3))

元组：元组与列表类似也是一种容器数据类型，可以用一个变量（对象）来存储多个数据，

不同之处在于元组的元素不能修改，在前面的代码中我们已经不止一次使用过元组了。顾名思义，

我们把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。

t = ('yamon', 24, True, '河北邯郸')
print(t)

获取元组内的内容

print(t[0])
for i in t:
print(i)

重新赋值

t = ('陈亚萌' ,24 ,True , '天津')
print(t)

将元组转化为列表：

person = list(t)
print(person)

利用列表修改元素，元组不允许修改元素

person[0] = 'yyh'
person[1] = 22
print(person)

列表转为元组

fruits_list = ['apple', 'banana', 'orange']
tuple=tuple(fruits_list)
print(tuple)

字典是另一种可变容器模型，Python中的字典跟我们生活中使用的字典是一样一样的，它可以存储任意类型对象，

与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。

下面的代码演示了如何定义和使用字典。

创建字典的字面量语法

scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
print(scores)

创建字典的构造器语法

items1 = dict(one=1, two=2, three=3, four=4)

通过zip函数将两个序列压成字典

items2 = dict(zip(['a', 'b', 'c'], '123'))

创建字典的推导式语法

items3 = {num: num ** 2 for num in range(1, 10)}
print(items1, items2, items3)

通过键可以获取字典中对应的值

print(scores['骆昊'])
print(scores['狄仁杰'])

对字典中所有键值对进行遍历

for key in scores:
print(f'{key}: {scores[key]}')

更新字典中的元素

scores['白元芳'] = 65
scores['诸葛王朗'] = 71
scores.update(冷面=67, 方启鹤=85)
print(scores)
if '武则天' in scores:
print(scores['武则天'])
print(scores.get('武则天'))

get方法也是通过键获取对应的值但是可以设置默认值

print(scores.get('武则天', 60))

删除字典中的元素

print(scores.popitem())
print(scores.popitem())
print(scores.pop('骆昊', 100))

清空字典

scores.clear()
print(scores)