学习python 第七天

python
字符串和常用数据结构
Python表示文本信息的方式就是用字符串类型。所谓字符串，就是由零个或多个字符组成的有限序列
len()计算字符串长度
.capitalize()将字符串首字母大写
.upper()将字符转为大写
.find() 从字符串查找子串所在位置 成功返回位置 失败返回-1
.index() 从字符串查找子串位置 成功返回位置 失败会报错
.startswith() 检查字符串是否以指定的字符串开头 成功返回True 失败返回False
.endswith()检查字符串是否以指定的字符串结尾 成功返回True 失败返回False
.center(a,b) 将字符串以指定的宽度居中并在两侧填充指定的字符 a代表一共展示多少个字符，b代表用哪种字符进行填充
.rjust(a,b) 将b字符填充到字符串左侧 一共展示a个字符
.isdigit() 检查字符串是否由数字构成 成功返回True 失败返回False
.isalpha()检查是否由字母组成 成功返回True 失败返回False
.isalnum() 检查字符串是否以数字和字母构成 成功返回True 失败返回False
.strip()去除字符串两边的空格

def main():
	str1 = 'hello shuaige'
	print(len(str1))
    print(len(str1))  # 13  len函数计算字符串的长度
    print(str1.capitalize())  # Hello shuaige   
    print(str1.upper())  # HELLO SHUAIGE
    print(str1.find('lo'))  # 3
    print(str1.find('lol'))  # -1
    print(str1.index('lo')) #3
    print(str1.index('lol')) #ValueError: substring not found
    print(str1.startswith('He'))  # False
    print(str1.startswith('hel'))  # True
    print(str1.center(50, '*'))  # ******************hello shuaige*******************
    print(str1.rjust(50, '1 ')) # 1111111111111111111111111111111111111hello shuaige
    print(str1.isdigit())  # False
    print(str1.isalpha())  # True
    print(str1.isalnum())  # False

 [a:b:c]
    a代表从哪开始（包含a）b代表从哪结束（不包含b） c代表中间隔（c-1）个字符
    
    str2 = 'abc123456'
    print(str2[2])  # c
    # 字符串切片(从指定的开始索引到指定的结束索引)
    print(str2[2:5])  # c12 从下标为2开始截取包含
    print(str2[2:])  # c123456
    print(str2[2::2])  # c246
    print(str2[::2])  # ac246
    print(str2[::-1])  # 654321cba
    print(str2[-3:-1])  # 45
    
    str3 = '  i love you    '
    print(str3)  #  i love you   
    print(str3.strip())  #i love you


if __name__ == '__main__':
    main()

除了字符串，Python数据结构包括列表、元组、集合和字典。

列表

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)  
    print(list1)  # [1, 3, 300, 7, 100，200]
    list1.insert(1, 400)
    print(list1) #  [1, 400,3, 300, 7, 100，200]
    list1 += [1000, 2000]
    print(list1)  # [1, 400,3, 300, 7, 100，200,1000, 2000]
    print(len(list1)) # 9
    # 删除元素
    list1.remove(3)  # [400, 300, 7, 100, 200, 1000, 2000]
    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()

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

def main():
    fruits = ['grape', 'apple', 'strawberry', 'waxberry']
	fruits += ['pitaya', 'pear', 'mango']
    # 列表切片
    fruits2 = fruits[1:4]
    print(fruits2)  #['apple', 'strawberry', 'waxberry']
    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()

下面的代码实现了对列表的排序操作。

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'] 按字母a-z
    print(list3)  #['zoo', 'orange', 'internationalization', 'blueberry', 'apple'] 按z-a
    print(list4)  #['zoo', 'apple', 'orange', 'blueberry', 'internationalization'] 按长度
    # 给列表对象发出排序消息直接在列表对象上进行排序
    list1.sort(reverse=True)  
    print(list1)  #['zoo', 'orange', 'internationalization', 'blueberry', 'apple'] 按z-a


if __name__ == '__main__':
    main()

我们还可以使用列表的生成式语法来创建列表，代码如下所示。

import sys

def main():
    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)


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()

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

def main():
    # 定义元组
    t = ('dsd', 2, 3, 'dfd')
    print(t)  #('dsd', 2, 3, 'dfd')
    # 获取元组中的元素
    print(t[0]) #dsd
    print(t[3]) #dfd
    # 遍历元组中的值
    for member in t:
        print(member)
    # 重新给元组赋值
    # t[0] = '王大锤'  # TypeError   无法更改
    # 变量t重新引用了新的元组原来的元组将被垃圾回收
    t = ('王大锤', 20, True, '云南昆明')
    print(t) #('王大锤', 20, True, '云南昆明')
    # 将元组转换成列表
    person = list(t)
    print(person) #['王大锤', 20, True, '云南昆明']
    # 列表是可以修改它的元素的
    person[0] = '李小龙'
    person[1] = 25
    print(person) #['李小龙', 25, True, '云南昆明']
    # 将列表转换成元组
    fruits_list = ['apple', 'banana', 'orange']
    fruits_tuple = tuple(fruits_list)
    print(fruits_tuple)  #('apple', 'banana', 'orange')


if __name__ == '__main__':
    main()

元祖和列表的区别

元组中的元素是无法修改的，如果不需要对元素进行添加、删除、修改的时候，可以考虑使用元组
元组在创建时间和占用的空间上面都优于列表。

使用集合
Python中的集合跟数学上的集合是一致的，不允许有重复元素，而且可以进行交集、并集、差集等运算。

def main():
    set1 = {1, 2, 3, 3, 3, 2}
    print(set1)  #set([1, 2, 3])
    print('Length =', len(set1))  #('Length =', 3)
    set2 = set(range(1, 10))  
    print(set2)  #set([1, 2, 3, 4, 5, 6, 7, 8, 9])
    set1.add(4)
    set1.add(5)
    set2.update([11, 12]) 
    print(set1)  #set([1, 2, 3, 4, 5])
    print(set2) #set([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)  #set([1, 2, 3, 6, 7, 8, 9, 11, 12])
    # 将元组转换成集合
    set3 = set((1, 2, 3, 3, 2, 1))
    print(set3.pop())  #1
    print(set3)  #set([2, 3])
    # 集合的交集、并集、差集、对称差运算
    print(set1 & set2)   #set([1, 2, 3])
    # print(set1.intersection(set2))  #set([1, 2, 3])
    print(set1 | set2)  #set([1, 2, 3, 6, 7, 8, 9, 11, 12])
    # print(set1.union(set2))  #set([1, 2, 3, 6, 7, 8, 9, 11, 12])
    print(set1 - set2)  #set([])
    # print(set1.difference(set2)) #set([])
    print(set1 ^ set2)  #set([6, 7, 8, 9, 11, 12])
    # print(set1.symmetric_difference(set2)) #set([6, 7, 8, 9, 11, 12])
    # 判断子集和超集
    print(set2 <= set1)   #False
    # print(set2.issubset(set1)) #False
    print(set3 <= set1) #True
    # print(set3.issubset(set1)) #True
    print(set1 >= set2)   #False
    # print(set1.issuperset(set2)) #False
    print(set1 >= set3)  #True
    # print(set1.issuperset(set3)) #True


if __name__ == '__main__':
    main()

使用字典
字典是另一种可变容器模型，类似于我们生活中使用的字典，它可以存储任意类型对象，与列表、集合不同的是，字典的每个元素都是由一个键和一个值组成的“键值对”，键和值通过冒号分开。

    def main():
        scores = {'a': 1, 'b': 2, 'c': 3}
        # 通过键可以获取字典中对应的值
        print(scores['a']) #1
        print(scores['c']) #3
        # 对字典进行遍历(遍历的其实是键再通过键取对应的值)
        for elem in scores:
            print('%s\t--->\t%d' % (elem, scores[elem]))  
           """
           	a	--->	1
    		c	--->	3
    		b	--->	2 
            """
    # 更新字典中的元素
    scores['a'] = 65
    scores['b'] = 71
    scores.update(a=67, b=85)
    print(scores)  #{'a': 67, 'c': 3, 'b': 85}
    if 'c' in scores:
        print(scores['c']) #3
    print(scores.get('c')) #3
    # get方法也是通过键获取对应的值但是可以设置默认值
    print(scores.get('武则天', 60)) #60
    # 删除字典中的元素
    print(scores.popitem())#('a', 67)
    print(scores.popitem()) #('c', 3)
    print(scores.pop('a', 100)) #100
    # 清空字典
    scores.clear()
    print(scores)  #{}


if __name__ == '__main__':
    main()