Day6_String_DataStructure

"""
使用字符串

Author:黄骏捷
Date:2019-09-28
"""
import sys

s1 = 'hello,world'
s2 = "hello,world"
#以三个双引号或单引号开头的字符串可以拆行
s3 = """
hello,
world!
"""
print(s1,s2,s3,end='')
print('-------------------------')


"""
反斜杠 \
"""
s1 = '\'hello,world!\''
s2 = '\n\\hello,world!\\\n'
print(s1,s2,end='')
print('-------------------------')

s1 = '\141\142\143\x61\x62\x63'
s2 = '\u9ec4\u9a8f\u6377'
print(s1, s2)
print('-------------------------')

"""
python有非常丰富的运算符
+ 实现字符串的拼接
* 重复一个字符串的内容
in和not in 判断一个字符串是否包含另外一个字符串
[]和[:] 从字符串取出某个字符或某些字符
"""
s1 = 'hello'*3
print(s1)
s2 = 'world'
s1+=s2
print(s1)
print('ll' in s1)
print('good' in s2)
str2 = 'abc123456'
#字符串切片(从指定的开始索引到指定的结束索引)
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 = '  [email protected] '
print(str3)
# 获得字符串修剪左右两侧空格之后的拷贝
print(str3.strip())
print('-------------------------')

"""
使用列表
"""
list1 = [1,3,5,7,100]
print(list1)
list2 = ['hello']*5
print(list2)

# 计算列表长度(元素个数)
print(len(list1))
# 下标(索引)运算
print(list1[0])
print(list1[4])
print(list1[-1])
print(list1[-3])
list1[2] = 300
print(list1)

#添加元素
list1.append(200)
print(list1)
list1.insert(1,400)
print(list1)
list1 += [1000,2000]
print(list1)

#删除元素
list1.remove(3)
if 1234 in list1:
    list1.remove(1234)
del list1[0]
print(list1)
#清空列表元素
list1.clear()
print(list1)
print('-------------------------')

"""
对列表进行切操作
"""
fruits = ['grape','apple','strawberry','waxberry']
fruits += ['pitaya', 'pear', 'mango']
# 循环遍历列表元素
for fruit in fruits:
    print(fruit.title(), end=' ')
print()

# 列表切片
fruits2 = fruits[1:4]
print(fruits2)

#没有复制只创建了新的引用
fruit3 = fruits
print(fruit3)

#通过完整切片操作来复制列表
fruits3 = fruits[:]
print(fruits3)
print('-------------------------')

"""
对列表的排序
"""
#sorted函数不会改变list1,函数的设计应尽可能不产生副作用
list1 = ['orange', 'apple', 'zoo', 'internationalization', 'blueberry']
list2 = sorted(list1)
print(list2)

#反过来
list3 = sorted(list1,reverse=True)
print(list3)

#根据字符串长度排序
list4 = sorted(list1,key=len)
print(list4)

# 给列表对象发出排序消息直接在列表对象上进行排序
list1.sort(reverse=True)
print(list1)
print('-------------------------')

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

f = [x for x in range(1, 10)]
print(f)

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

#生成器语法
# 请注意下面的代码创建的不是一个列表而是一个生成器对象
# 通过生成器可以获取到数据但它不占用额外的空间存储数据
# 每次需要数据的时候就通过内部的运算得到数据(需要花费额外的时间)
f = (x ** 2 for x in range(1, 5))
print(f)
print(sys.getsizeof(f))  # 相比生成式生成器不占用存储数据的空间
print(f)
#如何获取f的值？ 使用next
#print(next(f))
#print(next(f))
#print(next(f))
#print(next(f))
for val in f:
    print(val)

#另一种定义生成器的方式
#斐波拉切数列
def fib(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
        yield a     #执行到yield 后面代码不执行，需要for循环激活

def main():
    for val in fib(6):
        print(val)
if __name__ == '__main__':
    main()

"""
使用元组，与列表类似，不同之处在于元组不能修改
可以应用于多线程环境
一个不变的对象要比可变的对象更加容易维护
一个不变对象自动就是线程安全的，这样就可以省掉处理同步化的开销
元组在创建时间和占用的空间上面都优于列表

Author:黄骏捷
Date:2019-09-29
"""
#定义元组
t = ('黄骏捷',19,True,'弗南人')
print(t)

#遍历
for member in t:
    print(member)

#重新赋值
#   t[0] = '小马哥' #TypeError
#   变量t重新引用了新的元组，原来的元组将被垃圾回收
t = ('小马哥',19,True,'弗南人')   #true
print(t)

#元组切换成列表
person = list(t)
print(person)

# 列表是可以修改它的元素的
#   person[0] = '李小龙'

# 将列表转换成元组
fruits_list = ['apple', 'banana', 'orange']
fruits_tuple = tuple(fruits_list)
print(fruits_tuple)

"""
使用集合，和数学一样，没有重复元素
"""
set1 = {1,2,3,3,3,2}
print(set1)
print('Length =',len(set1)) #3 {1,2,3}

#赋值
set2 = set(range(1,10))
print(set2)

#添加
set1.add(4)
set1.add(5)
print(set1)

set2.update([11,12])
print(set2)

#去掉，如果不存在会发生KeyError
set2.discard(5)
print(set2)

if 4 in set2:
    set2.remove(4)
print(set2)

#遍历集合容器
for elem in set2:
    print(elem ** 2,end=' ')
print()

#将元组转换成集合
set3 = set((1,2,3,3,2,1))
print(set3.pop())
print(set3)

# 集合的交集，并集，差集，对称差运算  #后一行作用一样
print(set1 & set2)
# print(set1.intersection(set2))
print(set1 | set2)
# print(set1.union(set2))
print(set1 - set2)
# print(set1.difference(set2))
print(set1 ^ set2)
# print(set1.symmetric_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))


"""
使用字典，可变容器模型，可以储存任意类型对象，每个元素都是由一个键和一个值组成的"键值对"
"""
scores = {'黄骏捷':19,'刘牛妞':78,'德玛西亚':999}
#通过键可以获取字典中对应的值
print(scores['黄骏捷'])
print(scores['德玛西亚'])

#遍历
for elem in scores:
    print('%s\t--->\t%d' % (elem,scores[elem]))

#更新里面的值
scores['黄骏捷'] = 65
scores.update(黄骏捷=67,方启鹤=85)
print(scores)
print(scores.get('黄骏捷'))

# get方法通过键获取对应的值但是可以设置默认值
print(scores.get('秦始皇',60))

#删除字典中的元素
print(scores.popitem())
print(scores.pop('黄骏捷',100))

#清空字典
scores.clear()
print(scores)