学习历程按照Github上jackfrued的100天学习python的进度来进行，再辅上一些自己查找的相关资料。里面大部分代码都是采用这里面的内容。
对应传送门：https://github.com/jackfrued/Python-100-Days/tree/master/
Day07 字符串和常用数据结构
- 字符串常用函数
len(str) 获取字符换长度
str.find('abc') 获取字符串子串所在位置
str.rfind('abc') 返回字符串最后一次出现的位置(从右向左查询)，如果没有匹配项则返回-1
str.index('abc')获取字符串子串下标（与find类似但找不到子串时会发生异常）
str[2] 获取字符串指定位置字符
str[2:5] 获取字符串下标2到下标4的子串
str.strip() 获取字符串修剪左右两侧空格后的拷贝
str.startswith('abc') 检查字符串是否以对应字符开头
str.endswith('abc') 检查字符串是否以对应字符结尾
str.isdigit() 检查字符串是否由数字构成
str.isalpha() 检查字符串是否以字母组成
str.isalnum() 检查字符串是否以数字和字母构成
其余用法如下：
def main():
str1 = 'hello, world!'
# 通过len函数计算字符串的长度
print(len(str1)) # 13
# 获得字符串首字母大写的拷贝
print(str1.capitalize()) # 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[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
# 检查字符串是否由数字构成
print(str2.isdigit()) # False
# 检查字符串是否以字母构成
print(str2.isalpha()) # False
# 检查字符串是否以数字和字母构成
print(str2.isalnum()) # True
str3 = ' [email protected] '
print(str3)
# 获得字符串修剪左右两侧空格的拷贝
print(str3.strip())
if __name__ == '__main__':
main()
- 列表常用函数
len(list) 计算列表长度
list*5 复制原列表内容四次并将它们放入原列表后面
列表下标0 1 2 3 4等同于-5 -4 -3 -2 -1
list.append(element) 在列表后面添加元素
list.insert(element) 在列表前面添加元素
list += [1000,2000] 在列表后面添加[1000,2000]这两个元素
list.remove(obj) 移除列表中某个值的 第一个匹配项
list.clear() 清空列表元素
通过in和not in来判断某元素是否存在于/不存在于列表中
def main():
list1 = [1, 3, 5, 7, 100]
print(list1) #[1, 3, 5, 7, 100]
list2 = ['hello'] * 5
print(list2) #['hello', 'hello', '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]
# 添加元素
list1.append(200)
list1.insert(1, 400)
list1 += [1000, 2000]
print(list1)#[1, 400, 3, 300, 7, 100, 200, 1000, 2000]
print(len(list1))#9
# 删除元素
list1.remove(3)
if 1234 in list1:
list1.remove(1234)
del list1[0]
print(list1) #[400, 300, 7, 100, 200, 1000, 2000]
# 清空列表元素
list1.clear()
print(list1) #[]
if __name__ == '__main__':
main()
- 列表的切片
（1）遍历列表元素
for fruit in fruits:
print(fruit.title(), end=' ')
（2）list[1:4] 截取列表的第1到第3个元素
（3）fruits3 = fruits[:] 通过完整切片操作复制列表
def main():
fruits = ['grape', 'apple', 'strawberry', 'waxberry']
fruits += ['pitaya', 'pear', 'mango']
# 循环遍历列表元素
for fruit in fruits:
print(fruit.title(), end=' ')
#Grape Apple Strawberry Waxberry Pitaya Pear Mango
print()
# 列表切片
fruits2 = fruits[1:4]
#['apple', 'strawberry', 'waxberry']
print(fruits2)
# fruit3 = fruits # 没有复制列表只创建了新的引用
# 可以通过完整切片操作来复制列表
fruits3 = fruits[:]
print(fruits3)
#['grape', 'apple', 'strawberry', 'waxberry', 'pitaya', 'pear', 'mango']
fruits4 = fruits[-3:-1]
print(fruits4)
#['pitaya', 'pear']
# 可以通过反向切片操作来获得倒转后的列表的拷贝
fruits5 = fruits[::-1]
print(fruits5)
# ['mango', 'pear', 'pitaya', 'waxberry', 'strawberry', 'apple', 'grape']
if __name__ == '__main__':
main()
另外一个例子，
str = '0123456789'
str[1:5] → 【1,2,3,4】
str[1:-1:2] → 【1,3,5,7】
str[-2:2:-2] → 【8,6,4】
（该例子来源：https://blog.csdn.net/qq_33733970/article/details/75153866）
- 列表的排序通过sorted来进行（使用sort会修改原列表，sorted不会），如果要反向排序的话，需要加上reverse=true，例子：
def main():
list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
list2 = sorted(list1)
# sorted函数返回列表排序后的拷贝不会修改传入的列表
# 函数的设计就应该像sorted函数一样尽可能不产生副作用
list3 = sorted(list1, reverse=True)
# 通过key关键字参数指定根据字符串长度进行排序而不是默认的字母表顺序
list4 = sorted(list1, key=len)
print(list1) #['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
print(list2) #['apple', 'blueberry', 'internationalization', 'orange', 'zoo']
print(list3) #['zoo', 'orange', 'internationalization', 'blueberry', 'apple']
print(list4) #['zoo', 'apple', 'orange', 'blueberry', 'internationalization']
# 给列表对象发出排序消息直接在列表对象上进行排序
list1.sort(reverse=True)
print(list1) #['zoo', 'orange', 'internationalization', 'blueberry', 'apple']
if __name__ == '__main__':
main()
sorted函数的key可以指定按照上面类型进行排序顺序
（1）根据年龄排序
>>> student_tuples = [
... ('john', 'A', 15),
... ('jane', 'B', 12),
... ('dave', 'B', 10),
... ]
>>> sorted(student_tuples, key=lambda student: student[2]) # sort by age
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
（2）不区分大小写的字符串比较
>>> sorted("This is a test string from Andrew".split(), key=str.lower)
['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
python文档上关于排序的链接：https://docs.python.org/zh-cn/3/howto/sorting.html
5.通过列表的生成式语法来生成列表对象。
import sys
def main():
f = [x for x in range(1, 10)]
print(f) #[1, 2, 3, 4, 5, 6, 7, 8, 9]
f = [x + y for x in 'ABCDE' for y in '1234567']
print(f) #['A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'A7', 'B1', 'B2', 'B3', 'B4', 'B5', 'B6', 'B7', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'D1', 'D2', 'D3', 'D4', 'D5', 'D6', 'D7', 'E1', 'E2', 'E3', 'E4', 'E5', 'E6', 'E7']
# 用列表的生成表达式语法创建列表容器
# 用这种语法创建列表之后元素已经准备就绪所以需要耗费较多的内存空间
f = [x ** 2 for x in range(1, 1000)]
#[1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225...]
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)
if __name__ == '__main__':
main()
- 除了上面提到的生成器语法，Python中还有另外一种定义生成器的方式，就是通过
yield关键字将一个普通函数改造成生成器函数。下面的代码演示了如何实现一个生成[斐波拉切数列]的生成器。
def fib(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
yield a
def main():
for val in fib(20):
print(val)
if __name__ == '__main__':
main()
yield在函数中的功能类似于return，不同的是yield每次返回结果之后函数并没有退出，而是每次遇到yield关键字后返回相应结果，并保留函数当前的运行状态，等待下一次的调用。如果一个函数需要多次循环执行一个动作，并且每次执行的结果都是需要的，这种场景很适合使用yield实现。
包含yield的函数成为一个生成器，生成器同时也是一个迭代器，支持通过next方法获取下一个值。
一个带有 yield 的函数就是一个 generator，它和普通函数不同，生成一个 generator 看起来像函数调用，但不会执行任何函数代码，直到对其调用 next()（在 for 循环中会自动调用 next()）才开始执行。虽然执行流程仍按函数的流程执行，但每执行到一个 yield 语句就会中断，并返回一个迭代值，下次执行时从 yield 的下一个语句继续执行。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次，每次中断都会通过 yield 返回当前的迭代值。
yield 的好处是显而易见的，把一个函数改写为一个 generator 就获得了迭代能力，比起用类的实例保存状态来计算下一个 next() 的值，不仅代码简洁，而且执行流程异常清晰。
(来源：https://blog.csdn.net/dcrmg/article/details/78128041）
（另外一个参考链接：https://www.ibm.com/developerworks/cn/opensource/os-cn-python-yield/index.html）
- 关于元组，Python 的元组与列表类似，不同之处在于元组的元素不能修改。把多个元素组合到一起就形成了一个元组，所以它和列表一样可以保存多条数据。用例如下：
def main():
# 定义元组
t = ('骆昊', 38, True, '四川成都')
print(t)
# 获取元组中的元素
print(t[0])
print(t[3])
# 遍历元组中的值
for member in t:
print(member)
# 重新给元组赋值
# t[0] = '王大锤' # TypeError
# 变量t重新引用了新的元组原来的元组将被垃圾回收
t = ('王大锤', 20, True, '云南昆明')
print(t)
# 将元组转换成列表
person = list(t)
print(person)
# 列表是可以修改它的元素的
person[0] = '李小龙'
person[1] = 25
print(person)
# 将列表转换成元组
fruits_list = ['apple', 'banana', 'orange']
fruits_tuple = tuple(fruits_list)
print(fruits_tuple)
if __name__ == '__main__':
main()
如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组，当然如果一个方法要返回多个值，使用元组也是不错的选择。此外，元组在创建时间和占用的空间上面都优于列表。
-
关于集合，Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。
python-set.png
intersection 交集
union 并集
symmetricDifference 对称差（只属于其中一个集合，而不属于另一个集合的元素组成的集合，相当于异或）
subtracting 差集
例子：
def main():
set1 = {1, 2, 3, 3, 3, 2}
print(set1) #{1, 2, 3}
print('Length =', len(set1)) #Length = 3
set2 = set(range(1, 10))
print(set2)#{1, 2, 3, 4, 5, 6, 7, 8, 9}
set1.add(4)
set1.add(5)
set2.update([11, 12])
print(set1) #{1, 2, 3, 4, 5}
print(set2) #{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}
set2.discard(5)
# remove的元素如果不存在会引发KeyError
if 4 in set2:
set2.remove(4)
print(set2) #{1, 2, 3, 6, 7, 8, 9, 11, 12}
# 遍历集合容器
for elem in set2:
print(elem ** 2, end=' ') #1 4 9 36 49 64 81 121 144
print()
# 将元组转换成集合
set3 = set((1, 2, 3, 3, 2, 1))
print(set3.pop()) #1
print(set3) #{2, 3}
# 集合的交集、并集、差集、对称差运算
print(set1 & set2) #{1, 2, 3}
# print(set1.intersection(set2))
print(set1 | set2) #{1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12}
# print(set1.union(set2))
print(set1 - set2) #{4, 5}
# print(set1.difference(set2))
print(set1 ^ set2) #{4, 5, 6, 7, 8, 9, 11, 12}
# print(set1.symmetric_difference(set2))
# 判断子集和超集
print(set2 <= set1) #False
# print(set2.issubset(set1))
print(set3 <= set1) #True
# print(set3.issubset(set1))
print(set1 >= set2) #False
# print(set1.issuperset(set2))
print(set1 >= set3) #True
# print(set1.issuperset(set3))
if __name__ == '__main__':
main()
- 关于字典，字典是另一种可变容器模型，类似于我们生活中使用的字典，它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。（有点类似于C++里的map？）
def main():
scores = {'骆昊': 95, '白元芳': 78, '狄仁杰': 82}
# 通过键可以获取字典中对应的值
print(scores['骆昊']) #95
print(scores['狄仁杰']) #82
# 对字典进行遍历(遍历的其实是键再通过键取对应的值)
for elem in scores:
print('%s\t--->\t%d' % (elem, scores[elem])) #骆昊 ---> 95
白元芳 ---> 78
狄仁杰 ---> 82
# 更新字典中的元素
scores['白元芳'] = 65
scores['诸葛王朗'] = 71
scores.update(冷面=67, 方启鹤=85)
print(scores) # {'骆昊': 95, '白元芳': 65, '狄仁杰': 82, '诸葛王朗': 71, '冷面': 67, '方启鹤': 85}
if '武则天' in scores:
print(scores['武则天'])
print(scores.get('武则天')) #none
# get方法也是通过键获取对应的值但是可以设置默认值
print(scores.get('武则天', 60)) #60
# 删除字典中的元素
print(scores.popitem()) #('方启鹤', 85)
print(scores.popitem()) #('冷面', 67)
print(scores.pop('骆昊', 100)) #95
# 清空字典
scores.clear()
print(scores) #{}
if __name__ == '__main__':
main()
10.other部分
清除屏幕上的输出： os.system('cls') # os.system('clear')
休眠200毫秒 #time.sleep(0.2)
random模块的sample函数可以实现从列表中选择不重复的n个元素。
selected_balls = sample(list, n)