1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/7
 5 
 6 #列表的功能之创建
 7 #方法1-变量赋值；
 8 L1 = [] #定义一个空列表
 9 L2 = [‘‘,‘b‘,‘c‘,‘d‘]#存储4个值，索引为0~3
10 L3 = [‘abc‘,[‘def‘,‘ghi‘]]#嵌套列表
11 #方法2，使用python内置方法进行创建；
12 L2 = list()
13 print(L2)

1 #! /usr/bin/env python
2 # -*- coding:utf-8 -*-
3 #__author__ = "tqtl"
4 # Date:2018/5/7
5 L2 = [‘a‘,‘b‘,‘c‘,‘d‘,‘a‘,‘e‘,1,2]#定义一个列表L2；
6 print(L2[2])#通过索引取值；
7 print(L2[-1])#通过索引从列表右边开始取值；
8 print(L2.index(‘a‘))#返回指定元素的”索引值“，从左向右查找，找到第一个匹配字符；
9 print(L2.count(‘a‘))#统计指定元素的个数；

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/7
 5 #把列表当做一个面包，进行切分查找；
 6 L3 = [‘Shanshan‘,‘Longting‘,‘Alex‘,1,3,4,4,5,6,7,8,8,9,9,0,0,2,3,4,4]
 7 print(L3[0-2])#注意，0-2为-2，等价于print[L3[-2]]
 8 print(L3[0-3])#注意，0-3为-3，等价于print[L3[-3]]
 9 print(L3[0:3])#结果为：[‘Shanshan‘, ‘Longting‘, ‘Alex‘]，顾头不顾尾；
10 print(L3[3:7])#结果为：[1, 3, 4, 4]，
11 print(L3[-1:-5])#结果为空列表，切片的原则是，只能从左到右进行切分；
12 print(L3[-5:-1])#结果为：[0, 2, 3, 4]，仍旧顾头不顾尾；
13 print(L3[-5:0])#结果为：[]空列表
14 print(L3[-5:])#结果为：[0, 2, 3, 4, 4]
15 print(L3[0:3])#结果为：[‘Shanshan‘, ‘Longting‘, ‘Alex‘]
16 print(L3[:3])#结果为：[‘Shanshan‘, ‘Longting‘, ‘Alex‘]
17 print(L3[:])#结果为：[‘Shanshan‘, ‘Longting‘, ‘Alex‘, 1, 3, 4,4, 5, 6, 7, 8, 8, 9, 9, 0, 0, 2, 3, 4, 4]
18 print(L3[:7])#结果为：[‘Shanshan‘, ‘Longting‘, ‘Alex‘, 1, 3, 4, 4]
19 print(L3[0:7:2])#结果为：[‘Shanshan‘, ‘Alex‘, 3, 4],引入步长的概念
20 print(L3[:7:1])#结果为：[‘Shanshan‘, ‘Longting‘, ‘Alex‘, 1, 3, 4, 4]
21 print(L3[:-1:3])#结果为：[‘Shanshan‘, 1, 4, 7, 9, 0, 4]
22 print(L3[:-1:4])#结果为：[‘Shanshan‘, 3, 6, 9, 2]
23 print(L3[:])#结果为：[‘Shanshan‘, ‘Longting‘, ‘Alex‘, 1, 3, 4, 4, 5, 6, 7, 8, 8, 9, 9, 0, 0, 2, 3, 4, 4]
24 print(L3[::2])#结果为：[‘Shanshan‘, ‘Alex‘, 3, 4, 6, 8, 9, 0, 2, 4]

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/7
 5 #列表的插入与追加
 6 L4 = [‘Shanshan‘, ‘Longting‘, ‘Alex‘, 1, 3, 4, 4, 5, 6, 7, 8, 8, 9, 9, 0, 0, 2, 3, 4, 4]
 7 L4.append(‘Peiqi‘)#append方法是“追加”的意思，只能插入到结尾；
 8 print(L4)#结果为：[‘Shanshan‘, ‘Longting‘, ‘Alex‘, 1, 3, 4, 4, 5, 6, 7, 8, 8, 9, 9, 0, 0, 2, 3, 4, 4, ‘Peiqi‘]
 9 L4.insert(0,‘abc‘)#insert方法是根据索引值，进行插入数据；
10 print(L4)
11 L4.insert(2,‘Alex‘)
12 print(L4)
13 #列表的修改-根据索引值修改；
14 print(L4[3])
15 L4[3] = "龙婷"#列表值的修改，使用重新赋值的方法；
16 print(L4)#结果为：[‘abc‘, ‘Shanshan‘, ‘Alex‘, ‘龙婷‘, ‘Alex‘, 1, 3, 4, 4, 5, 6, 7, 8, 8, 9, 9, 0, 0, 2, 3, 4, 4, ‘Peiqi‘]
17 #列表的修改-根据索引值的范围修改；
18 print(L4[4:6])#通过索引范围，进行批量修改；
19 L4[4:6] = "JACK LIU"# "JACK LIU"分别表示‘J‘, ‘A‘, ‘C‘, ‘K‘, ‘ ‘, ‘L‘, ‘I‘, ‘U‘注意中间有空格，总结8个元素；
20 print(L4)#结果为：[‘abc‘, ‘Shanshan‘, ‘Alex‘, ‘龙婷‘, ‘J‘, ‘A‘, ‘C‘, ‘K‘, ‘ ‘, ‘L‘, ‘I‘, ‘U‘, 3, 4, 4, 5, 6, 7, 8, 8, 9, 9, 0, 0, 2, 3, 4, 4, ‘Peiqi‘]

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/7
 5 #列表的插入与追加
 6 L4 = [‘Shanshan‘, ‘Longting‘, ‘Alex‘, 1, 3, 4, 4, 5, 6, 7, 8, 8, 9, 9, 0, 0, 2, 3, 4, 4]
 7 L4.append(‘Peiqi‘)#append方法是“追加”的意思，只能插入到结尾；
 8 print(L4)#结果为：[‘Shanshan‘, ‘Longting‘, ‘Alex‘, 1, 3, 4, 4, 5, 6, 7, 8, 8, 9, 9, 0, 0, 2, 3, 4, 4, ‘Peiqi‘]
 9 L4.insert(0,‘abc‘)#insert方法是根据索引值，进行插入数据；
10 print(L4)
11 L4.insert(2,‘Alex‘)
12 print(L4)
13 #列表的修改-根据索引值进行重新赋值修改；
14 print(L4[3])
15 L4[3] = "龙婷"#列表值的修改，使用重新赋值的方法；
16 print(L4)#结果为：[‘abc‘, ‘Shanshan‘, ‘Alex‘, ‘龙婷‘, ‘Alex‘, 1, 3, 4, 4, 5, 6, 7, 8, 8, 9, 9, 0, 0, 2, 3, 4, 4, ‘Peiqi‘]
17 #列表的修改-根据索引值的范围修改
18 print(L4[4:6])#通过索引范围，进行批量修改；
19 L4[4:6] = "JACK LIU"# "JACK LIU"分别表示‘J‘, ‘A‘, ‘C‘, ‘K‘, ‘ ‘, ‘L‘, ‘I‘, ‘U‘注意中间有空格，总结8个元素；
20 print(L4)#结果为：[‘abc‘, ‘Shanshan‘, ‘Alex‘, ‘龙婷‘, ‘J‘, ‘A‘, ‘C‘, ‘K‘, ‘ ‘, ‘L‘, ‘I‘, ‘U‘, 3, 4, 4, 5, 6, 7, 8, 8, 9, 9, 0, 0, 2, 3, 4, 4, ‘Peiqi‘]

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/7
 5 #列表的循环和排序
 6 L6 = [‘Shanshan‘, ‘Peiqi‘,  ‘ ‘, ‘L‘, ‘I‘, ‘U‘, 3,4, 5, 6, 7,7, 8, 8, 9, 9, 0, 0, 2, 3, 4, 4]
 7 for i in L6:#i是临时变量；for循环；
 8     print(‘loop‘,i)
 9 #range(10)，与Python2.x不同，
10 for i in range(10):
11     print(i)
12 #for循环与while循环的区别；while循环可以是死循环，但for循环有边界，不会出现死循环，区别在于有无循环边界；

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/7
 5 L7 = [‘a‘,‘e‘,‘b‘,1,34,2,‘c‘]
 6 #L7.sort()#使用sort方法来排序；
 7 #print(L7)#TypeError: ‘<‘ not supported between instances of ‘int‘ and ‘str‘,int和str没有关系，所以无法排序；
 8 L7.remove(1)#使用remove方法，删除指定元素值；
 9 L7.remove(34)
10 L7.remove(2)
11 print(L7)
12 L7.append(‘z‘)#列表的追加；
13 L7.insert(1,‘y‘)#根据索引值进行增加；
14 L7.insert(3,‘A‘)
15 print(L7)
16 L7.sort()#列表的排序sort方法；
17 print(L7)
18 L7.insert(3,‘#‘)
19 L7.insert(3,‘*‘)
20 L7.insert(3,‘!‘)
21 print(L7)#其实，排序规则是按照列表中元素的位于ASCII码表中的位置进行排列显示的；
22 L7.reverse()#列表的反转reverse方法与sort互逆；
23 print(L7)
24 L8 = [1,2,4]#新建一个列表；
25 L7.extend(L8)#列表的拓展方法；
26 print(L7)
27 L9 = L7.copy()#列表的copy方法；
28 print(L9)
29 L7.clear()#列表的清空，注意与删除操作不相同，前者是对内容级别进行操作；后者是列表级别操作；
30 print(L7)#

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Project: DevelopBasic 
# Software: PyCharm
# DateTime: 2018-10-10 22:19
# File: 12-列表练习题讲解.py
# __author__: 天晴天朗
# Email: tqtl@tqtl.org

# 1、创建一个空列表，命名为names，往里面天添加old_driver，rain，jack，shanshan，peiqi，black，black_girl元素；
names = []
names.append("old_driver")
names.append("rain")
names.append("jack")
names.append("shanshan")
names.append("peiqi")
names.append("black")
names.append("black_girl")
print("No.01:", names)  # No.01 [‘old_driver‘, ‘rain‘, ‘jack‘, ‘shanshan‘, ‘peiqi‘, ‘black‘, ‘black_girl‘]

# 2、往names列表里black_girl前面插入一个alex;
names.insert(names.index("black_girl"), "alex")
print("No.02:", names)  # No.02: [‘old_driver‘, ‘rain‘, ‘jack‘, ‘shanshan‘, ‘peiqi‘, ‘black‘, ‘alex‘, ‘black_girl‘]

# 3、把shanshan的名字改成中文"姗姗";

names[names.index("shanshan")] = "姗姗"
print("No.03:", names)  # No.03: [‘old_driver‘, ‘rain‘, ‘jack‘, ‘姗姗‘, ‘peiqi‘, ‘black‘, ‘alex‘, ‘black_girl‘]

# 4、往names列表里rain的后面插入一个子列表["oldboy", "oldgirl"]
names.insert(names.index("rain") + 1, ["oldboy", "oldgirl"])
print("No.04:", names)
# No.04: [‘old_driver‘, ‘rain‘, [‘oldboy‘, ‘oldgirl‘], ‘jack‘, ‘姗姗‘, ‘peiqi‘, ‘black‘, ‘alex‘, ‘black_girl‘]

# 5、返回peiqi的索引;
print("No.05:", names.index("peiqi"))  # No.05: 5

# 6、创建新列表[1,2,3,4,2,5,6,2]，合并入names列表;
nums = list(range(1, 5))
nums.append(2)
nums.append(5)
nums.append(6)
nums.append(2)
combine = names + nums
print("No.06:", combine)  #
# No.06: [‘old_driver‘, ‘rain‘, [‘oldboy‘, ‘oldgirl‘], ‘jack‘, ‘姗姗‘, ‘peiqi‘, ‘black‘, ‘alex‘, ‘black_girl‘, 1, 2, 3, 4, 2, 5, 6, 2]

# 7、取出names列表中索引4-7的元素
print("No.07:", names[4:8])  # No.07: [‘姗姗‘, ‘peiqi‘, ‘black‘, ‘alex‘]
#
# 8、取出names列表中索引2-10的元素，步长为2
print("No.08:", names[2:11:2])  # No.08: [[‘oldboy‘, ‘oldgirl‘], ‘姗姗‘, ‘black‘, ‘black_girl‘]

# 9、取出names列表中最后3个元素;
print("No.09:", names[-3:])  # No.09: [‘black‘, ‘alex‘, ‘black_girl‘]
print("此处为分隔符0".center(120, ‘-‘))
# 10、循环names列表，打印每个元素的索引值和元素;

# 方法01：
count = 0
for name in names:
    print("No.10-1", count, name)
    count += 1
"""
0 old_driver
1 rain
2 [‘oldboy‘, ‘oldgirl‘]
3 jack
4 姗姗
5 peiqi
6 black
7 alex
8 black_girl
"""
print("此处为分隔符1".center(120, ‘-‘))
# 方法02：enumerate(names) 枚举；
print(enumerate(names))  # 直接取索引，<enumerate object at 0x107a17a68>
for name in enumerate(names):
    print("No.10-2", name)  # 打印的值是一个小列表
print("此处为分隔符2".center(120, ‘-‘))
"""
(0, ‘old_driver‘)
(1, ‘rain‘)
(2, [‘oldboy‘, ‘oldgirl‘])
(3, ‘jack‘)
(4, ‘姗姗‘)
(5, ‘peiqi‘)
(6, ‘black‘)
(7, ‘alex‘)
(8, ‘black_girl‘)
"""
for index, name in enumerate(names):
    print("No.10-3", index, name)  # 打印的值不是列表了
print("此处为分隔符3".center(120, ‘-‘))
"""
0 old_driver
1 rain
2 [‘oldboy‘, ‘oldgirl‘]
3 jack
4 姗姗
5 peiqi
6 black
7 alex
8 black_girl
"""
# 11、循环names列表，打印每个元素的索引值和元素，当索引值为偶数，把对应的元素改成-1
for index, name in enumerate(names):
    if index % 2 == 0:  # 代表偶数
        names[index] = -1
        print("No.11", index, name)  # 打印的值不是列表了;
print("No.11", names)
print("此处为分隔符".center(120, ‘-‘))
# # 12、names里有3个2，请返回第2个2的索引值，不要人肉数，要动态找（提示，找到第一个2的位置，在此基础上再找第2个）

# 方法一：
names = [‘cuixiaozhao‘, 2, ‘cuixiaoshan‘, ‘cuixiaosi‘, 2, ‘cuixiaolei‘, 1, 3, 4, 2]
count = 0
for i in names[names.index(2) + 1:]:
    if i == 2:
        print("第二个2的index:", names.index(2) + 1 + count)
        break
    count += 1
# 方法二:
first_index = names.index(2)  # 第一个2的索引值
new_list = names[first_index + 1:]  # 从第一个2的位置+1 开始切片，重新赋值给新的列表
second_index = new_list.index(2)  # 查询2 在新的列表中的索引值
last_index = first_index + second_index + 1  # 第一个的索引值+ ‘第二个的索引值+切片时候的+1‘
print("第二个2 的index:", last_index)

# 13、现有商品列表如下：
products = [[‘Iphone8‘, 6888], [‘MacPro‘, 14800], [‘小米6‘, 2499], [‘Coffee‘, 31], [‘Book‘, 80], [‘Nike Shoes‘, 799]]
"""
需打印出这样的格式
---------商品列表----------
0. Iphone8    6888
1. MacPro    14800
2. 小米6    2499
3. Coffee    31
4. Book    80
5. Nike Shoes    799
"""
print("商品列表".center(60, ‘-‘))
for index, product in enumerate(products):
    # print("%s %s %s" % (str(index) + ".", product[0], product[1]))
    print("%s. %s %s" % (index, product[0], product[1]))

# 14、写一个循环，不断的问用户想买什么，用户选择一个商品编号，就把对应的商品添加到购物车里，最终用户输入q退出时，打印购物车里边的商品列表
shopping_cart = []
while True:
    for index, product in enumerate(products):
        print("%s. %s %s" % (index, product[0], product[1]))
    want = input("您想要买什么，请输入对象商品编号： 例<2>,输入<q>退出 >>")
    if want.isdigit():
        want = int(want)
        if want > len(products) - 1 and want < 0:
            print("输入商品编号错误，没有该编号!!")
        else:
            shopping_cart.append(products[want])
            print("已经将%s加入购物车" % products[want])
    elif want == "q":
        if len(shopping_cart) > 0:
            print("您已购买以下商品：")
            for index, i in enumerate(shopping_cart):
                print("%s. %s %s" % (index, i[0], i[1]))
        break
    else:
        print("输入不正确！")
        continue

# 知识补充：

# 判断字符串是否是一个数字;
"33".isdigit()

# 查看列表的长度;
len(names)

# break 退出也可以用标志位来设置True False 进行循环判断退出;
# 标志位;
flag = True
while flag:
    if 100:
        pass
    else:
        flag = False  # 标志位 设置False 结束循环; 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# Project: DevelopBasic 
# Software: PyCharm
# DateTime: 2018-10-11 12:17
# File: 14-深浅拷贝.py
# __author__: 天晴天朗
# Email: tqtl@tqtl.org
""
"""
Python3中存在的深浅拷贝；
"""
# 变量举例:
a = 1
b = a
print("a:", a)
print("b:", b)
print("id(a):", id(a))
print("id(b):", id(b))
print("这里是分隔符".center(100, ‘-‘))
a = 2
print("b:", b)
print("a:", a)
print("id(b):", id(b))
print("id(a):", id(a))
print("这里是分隔符".center(100, ‘-‘))

# 列表举例:
names = [‘cuixiaozhao‘, ‘cuixiaoshan‘, ‘cuixiaosi‘, ‘cuixiaolei‘, ‘cuixiaoyan‘]
names2 = names
print("names:", names)  # names: [‘cuixiaozhao‘, ‘cuixiaoshan‘, ‘cuixiaosi‘, ‘cuixiaolei‘, ‘cuixiaoyan‘]
print("names2:", names2)  # names2: [‘cuixiaozhao‘, ‘cuixiaoshan‘, ‘cuixiaosi‘, ‘cuixiaolei‘, ‘cuixiaoyan‘]

print("names的id值:", id(names), "names2的id值:", id(names2))  # names的id值: 4422633096 names2的id值: 4422633096

print(id(names[1]), id(names2[1]))  # 4560274288 4560274288
names[0] = "崔晓昭"
print(names)
print(names2)
print("这里是分隔符".center(100, ‘-‘))

print("此时的names:", names)  # 此时的names: [‘崔晓昭‘, ‘cuixiaoshan‘, ‘cuixiaosi‘, ‘cuixiaolei‘, ‘cuixiaoyan‘]
names_copy2 = names.copy()
print("names的浅拷贝之names_copy2:", names_copy2)
print("names的id值:", id(names), "names_copy2的id值:", id(names_copy2))
print(id(names[1]), id(names_copy2[1]))  # 4480082800 4480082800
print("这里是分隔符3".center(100, ‘-‘))

names.append([‘崔天晴‘, ‘崔天朗‘])
names_copy2.append([‘cxz‘, ‘cxs‘])
names_copy3 = names.copy()
print(names)
print(names2)
print(names_copy2)
print(names_copy3)
"""
[‘崔晓昭‘, ‘cuixiaoshan‘, ‘cuixiaosi‘, ‘cuixiaolei‘, ‘cuixiaoyan‘, [‘崔天晴‘, ‘崔天朗‘]]
[‘崔晓昭‘, ‘cuixiaoshan‘, ‘cuixiaosi‘, ‘cuixiaolei‘, ‘cuixiaoyan‘, [‘崔天晴‘, ‘崔天朗‘]]
[‘崔晓昭‘, ‘cuixiaoshan‘, ‘cuixiaosi‘, ‘cuixiaolei‘, ‘cuixiaoyan‘, [‘cxz‘, ‘cxs‘]]
[‘崔晓昭‘, ‘cuixiaoshan‘, ‘cuixiaosi‘, ‘cuixiaolei‘, ‘cuixiaoyan‘, [‘崔天晴‘, ‘崔天朗‘]]
"""
print(id(names))
print(id(names2))
print(id(names_copy2))
print(id(names_copy3))
"""
4410074760
4410074760
4410074824
4409935048
"""
names[-1][0] = "2020"
print(names)
print(names2)
print(‘-----------------***********--------------------------‘)
print(names_copy2)
print(names_copy3)
print(‘-----------------***********--------------------------‘)
print(id(names[-1][0]))
print(id(names2[-1][0]))
print(id(names_copy2[-1][0]))
print(id(names_copy3[-1][0]))
"""
4537801168
4537801168
4537800552
4537801168
"""

# 不建议使用deepcopy;
import copy

n4 = copy.deepcopy(names)
print(n4)
print(names)

print(‘----------------------‘)
names[-1][0] = 19930911
print(names)
print(n4)
print(id(names[-1][0]))
print(id(n4[-1][0]))

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/8
 5 s = "Hello World!"
 6 print(s.capitalize())#Hello world!首字母大写；
 7 print(s.center(50,‘*‘))#*******************Hello World!*******************
 8 print(s.center(50,‘-‘))#-------------------Hello World!-------------------
 9 print(s.count(‘o‘))#全局统计字符o的数量；2；
10 print(s.count(‘o‘,0,5))#指定范围统计字符o的数量；1；
11 print(s.endswith(‘!‘))#返回布尔值True；
12 print(s.endswith(‘!jfdskl‘))#返回布尔值False；
13 s2 = ‘a\tb‘
14 print(s2)#a、b；默认字符长度；
15 print(s2.expandtabs(20))#a、b中间指定数量的字符长度；；
16 print(s.find(‘o‘))#4
17 print(s.find(‘ofdjskl‘))#-1
18 print(s.find(‘o‘,0,5))#4
19 print(s.find(‘o‘,0,4))#-1,顾头不顾尾；
20 print(s.find(‘W‘,0,120))#6,顾头不顾尾；
21 s3 = "my name is {0},i am {1} years old."
22 print(s3.format(‘TQTL‘,26))#my name is TQTL,i am 26 years old.
23 s3 = "my name is {name},i am {age} years old."
24 #print(s3.format(‘TQTL‘,26))#KeyError: ‘name‘
25 print(s3.format(name=‘cuixiaozhao‘,age=26))#my name is cuixiaozhao,i am 26 years old.

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/8
 5 s = "Hello World!"
 6 print(s.index(‘o‘))#返回字符的索引值，默认是全局查找：4
 7 #print(s.index(‘o‘,8,10))#ValueError: substring not found；指定范围查找；
 8 s1 = "1993"
 9 print(s1.isalnum())#True，判断长得像不像数字；
10 s2 = "cxz19930911"
11 print(s2.isalnum())#True；
12 s3 = "cuixiaozhao"
13 print(s1.isalpha())#False；
14 print(s2.isalpha())#False；
15 print(s3.isalpha())#True；
16 s4 = ‘18.88‘#首先它得是字符串，此处不可以为s4 = 18.88；
17 s5 =‘18‘#首先它得是字符串，此处不可以为s4 = 18；
18 print(s4.isdecimal())#False；
19 print(s5.isdecimal())#True；
20 print(s4.isdigit())#False；
21 print(s5.isdigit())#True；
22 s6 = "names"
23 print(s.isidentifier())#判断是否为合法的变量；
24 print(s4.isidentifier())
25 print(s6.isidentifier())
26 print(‘cxs19920619‘.isnumeric())#判断是否仅有数字在里面；
27 print(‘19930911‘.isnumeric())#判断是否仅有数字在里面；
28 print(‘19971224‘.isprintable())#Linux中一切皆文件，判断是不是可以打印，文本文件；
29 print(‘19971224fdsf‘.isprintable())#Linux中一切皆文件，判断是不是可以打印，文本文件；
30 print(‘A B C‘.isspace())#判断是不是空格space空格的意思；
31 print(‘A BC‘.isspace())
32 print(‘‘.isspace())
33 print(‘ ‘.isspace())
34 s7 = "Important News"
35 s8 = "HAPPY FAMILY"
36 print(s7.istitle())#新闻标题单词首字母均为大写，判断是不是title；
37 print(s7.isupper())#判断是不是全为大写；
38 print(s8.isupper())#判断是不是全为大写；
39 names = [‘alex‘,‘jack‘,‘rain‘]
40 print(‘‘.join(names))#alexjackrain；
41 print(‘-‘.join(names))#alex-jack-rain；
42 print(‘*‘.join(names))#alex*jack*rain；
43 print(‘^‘.join(names))#alex^jack^rain；
44 s9 = ‘Hello World!‘
45 s10 = ‘hello world!‘
46 s11 = ‘HELLO WOLRD!‘
47 print(s9.ljust(50,‘-‘))#Hello World!--------------------------------------
48 print(s9.rjust(50,‘-‘))#--------------------------------------Hello World!
49 print(s9.upper())#HELLO WORLD!
50 print(s9.lower())#hello world!
51 print(s11.isupper())#True
52 print(s10.islower())#True
53 s12 = ‘\n hello world!你好 世界            ‘
54 print(s12.strip())#hello world!你好 世界 ；去掉左右两侧多余字符；
55 print(s12.lstrip())#hello world!你好 世界；
56 print(s12.rstrip())#hello world!你好 世界；
57 str_in = ‘abcdef‘
58 str_out = ‘!@#$%^‘
59 s13 = ‘xzabcdsaef‘
60 table = str.maketrans(str_in,str_out)#先生成对应关系表；
61 print(table)#{97: 33, 98: 64, 99: 35, 100: 41, 101: 94, 102: 40}
62 print(s13.translate(table))#xz!@#$s!%^；
63 s14 = ‘cuixiaozhao‘
64 print(s14.partition(‘o‘))#(‘cuixia‘, ‘o‘, ‘zhao‘)
65 print(s14.replace(‘a‘,‘MM‘))
66 print(s14.replace(‘a‘,‘MM‘,1))#指定更换的次数；
67 print(s14.rfind(‘o‘))#从右侧开始查找；
68 print(s14.rfind(‘fdsafd‘))#从右侧开始查找，找不到返回值-1；
69 print(s14.rfind(‘fdsafd‘,0,10))#从右侧开始查找，指定范围，找不到返回值-1；
70 #print(s14.rindex(‘fdsafd‘,0,10))#从左侧开始查找，指定范围，找不到会报错：ValueError: substring not found；
71 #print(s14.rindex(‘o‘,0,5))#从右侧开始查找，指定范围，找不到会报错：ValueError: substring not found；
72 print(s14.rindex(‘o‘,0,10))#从右侧开始查找，指定范围，返回索引值；
73 s15 = ‘Hello World!‘
74 print(s15.rpartition(‘o‘))#(‘Hello W‘, ‘o‘, ‘rld!‘)
75 print(s15.split(‘e‘))#[‘H‘, ‘llo World!‘]
76 print(s15.split(‘o‘))#[‘Hell‘, ‘ W‘, ‘rld!‘]
77 print(s15.split(‘l‘))#[‘He‘, ‘‘, ‘o Wor‘, ‘d!‘]
78 print(s15.rsplit(‘o‘,1))#[‘Hello W‘, ‘rld!‘],指定次数分割；
79 s16 = ‘a\nb\nalex\ncuixiaozhao‘
80 print(s16.splitlines())#[‘a‘, ‘b‘, ‘alex‘, ‘cuixiaozhao‘]按照行来进行分割；
81 s17 = ‘hello world‘
82 print(s17.startswith(‘he‘))#True
83 print(s17.startswith(‘He‘))#False
84 print(s17.startswith(‘fdsk‘))#False
85 print(s17.endswith(‘fdsk‘))#False
86 print(s17.endswith(‘rld‘))#True
87 print(s17.endswith(‘RLD‘))#Flase
88 print(s17.swapcase())#HELLO WORLD,小写变成大写；
89 print(s17.title())#Hello World，将字符串编程title类型的；
90 print(s17.zfill(20))#000000000hello world，将字符串变成20位长度，不够的用0填充；
91 #isdigit,replace,find,count,strip,center,split,format,join

1 names = (‘cuixiaozhao‘,[‘a‘,‘b‘],1,2,[1,2,3,4,5])#创建names元组；
2 names[1][0]=‘TQTL‘#对names元组中的子列表进行修改；
3 print(names)#(‘cuixiaozhao‘, [‘TQTL‘, ‘b‘], 1, 2, [1, 2, 3, 4, 5])

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/8 7:25
 5 #需求：存储公司60~70人的姓名、年龄、性别、手机号、部门、岗位、家乡....
 6 names = [
 7     [‘Alex‘,26,‘技术部‘,‘工程师‘,13651054608],
 8     [‘Shanshan‘,25,‘公关部‘,‘野模‘,13374245235],
 9     [‘龙婷‘,24,‘设计部‘,‘UI‘,13824234452],
10 ]
11 #print(names.index(‘龙婷‘))#ValueError: ‘龙婷‘ is not in list；
12 print(names.index([‘龙婷‘,24,‘设计部‘,‘UI‘,13824234452]))#妈的，我都知道这么多信息了，我查询它（索引2）有病呀！
13 info = {}#定义一个空字典；
14 info = {
15     ‘龙婷‘:[24,‘design‘,‘UI‘,13811221893],
16     ‘shanshan‘:[25,‘PR‘,‘wild model‘,13681590211]
17 }
18 print(info[‘龙婷‘])#返回值：[24, ‘design‘, ‘UI‘, 13811221893]
19 #修改信息
20 mod = info[‘龙婷‘][1]=‘设计部‘
21 print(mod)#设计部
22 print(info)#{‘龙婷‘: [24, ‘设计部‘, ‘UI‘, 13811221893], ‘shanshan‘: [25, ‘PR‘, ‘wild model‘, 13681590211]}
23 #字典的查找速速快的原因，因为hash查找速度快；
24 print(hash(‘龙婷‘))#哈希值：7073574030525645556；
25 print(hash(‘Shanshan‘))#哈希值：232415886153887154；
26 numbers = [13334,-32424,25532,2364]
27 numbers.append(3355)
28 numbers.append(123334)
29 print(numbers)#[13334, -32424, 25532, 2364, 3355, 123334]
30 numbers.sort()；
31 print(numbers)#[-32424, 2364, 3355, 13334, 25532, 123334]
32 #通过折半查找，就可很快滴查找到值（二分查找）；

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/8 21:51
 5 info = {
 6     ‘stu1101‘:‘TengLan Wu‘,
 7     ‘stu1102‘: ‘LongZe Luola‘,
 8     ‘stu1103‘: ‘XiaoZe Maliya‘
 9  }#定义了字典info,如何判断，{}、[]、（）的区别；
10 info[‘stu1104‘] = "苍井空"#字典的添加，有则重新赋值，无则新增一键值对；
11 print(info)#{‘stu1101‘: ‘TengLan Wu‘, ‘stu1102‘: ‘LongZe Luola‘, ‘stu1103‘: ‘XiaoZe Maliya‘, ‘stu1104‘: ‘苍井空‘}
12 #字典的修改；
13 info[‘stu1101‘] = "武藤兰"#通过键值，进行字典的重新赋值，进行相应的修改；
14 print(info)#{‘stu1101‘: ‘武藤兰‘, ‘stu1102‘: ‘LongZe Luola‘, ‘stu1103‘: ‘XiaoZe Maliya‘, ‘stu1104‘: ‘苍井空‘}
15 #字典的查询；
16 print("stu1102" in info)#True
17 print(info.get(‘stu1102‘))#LongZe Luola；
18 print(info.get(‘stu110211111111‘))#None；
19 print(info[‘stu1102‘])#LongZe Luola；不推荐使用，如果不存在会报错！
20 #print(info[‘stu1102-11111111‘])#KeyError: ‘stu1102-11111111‘，所以一般会优先使用字典中的get方法；
21 #print(info.pop())#TypeError: pop expected at least 1 arguments, got 0
22 print(info.pop(‘stu1101‘))#pop方法删除字典元素，有返回值：武藤兰；
23 print(info)#{‘stu1102‘: ‘LongZe Luola‘, ‘stu1103‘: ‘XiaoZe Maliya‘, ‘stu1104‘: ‘苍井空‘}
24 #字典的添加
25 info[4] = ‘Number1‘#增加；
26 info[3] = ‘Number2‘
27 info[2] = ‘Number3‘
28 info[1] = ‘Number4‘
29 print(info)#{‘stu1102‘: ‘LongZe Luola‘, ‘stu1103‘: ‘XiaoZe Maliya‘, ‘stu1104‘: ‘苍井空‘, 4: ‘Number1‘, 3: ‘Number2‘, 2: ‘Number3‘, 1: ‘Number4‘}
30 #字典的删除操作；
31 print(info.popitem())#字典是无序的，随机删除字典中的元素；(1, ‘Number4‘)；
32 print(info.popitem())#字典是无序的，随机删除字典中的元素；(2, ‘Number3‘)；
33 for i in range(100):
34     info[i]= ‘Number‘+(str(i))#for循环向字典中增添数据；
35 print(info.popitem())#popitem是无序随机删除；
36 print(info.popitem())
37 print(info.popitem())
38 print(info.popitem())
39 print(info.popitem())
40 print(info.popitem())
41 del info[56]#使用字典的del 方法进行删除；
42 #多级字典的嵌套——字典里面套字典；
43 av_catalog = {
44     "欧美":{
45         "www.youporn.com": ["很多免费的,世界最大的","质量一般"],
46         "www.pornhub.com": ["很多免费的,也很大","质量比yourporn高点"],
47         "letmedothistoyou.com": ["多是自拍,高质量图片很多","资源不多,更新慢"],
48         "x-art.com":["质量很高,真的很高","全部收费,屌丝请绕过"]
49     },
50     "日韩":{
51         "tokyo-hot":["质量怎样不清楚,个人已经不喜欢日韩范了","听说是收费的"]
52     },
53     "大陆":{
54         "1024":["全部免费,真好,好人一生平安","服务器在国外,慢"]
55     }
56 }
57 #字典的修改；
58 av_catalog["大陆"]["1024"][1] = "没关系，可以使用爬虫爬取下来，后续我们会讲爬虫课程的，注意认真听讲哦srapy"#多级字典的逐级查找；
59 print(av_catalog)
60 #{‘欧美‘: {‘www.youporn.com‘: [‘很多免费的,世界最大的‘, ‘质量一般‘], ‘www.pornhub.com‘: [‘很多免费的,也很大‘, ‘质量比yourporn高点‘
61 # ], ‘letmedothistoyou.com‘: [‘多是自拍,高质量图片很多‘, ‘资源不多,更新慢‘], ‘x-art.com‘: [‘质量很高,真的很高‘, ‘全部收费,屌比请绕过
62 # ‘]}, ‘日韩‘: {‘tokyo-hot‘: [‘质量怎样不清楚,个人已经不喜欢日韩范了‘, ‘听说是收费的‘]}, ‘大陆‘: {‘1024‘: [‘全部免费,真好,好人一生平安
63 # ‘, ‘没关系，可以使用爬虫爬取下来，后续我们会讲爬虫课程的，注意认真听讲哦srapy‘]}}
64 #字典的其他方法；
65 info.clear()#针对字典进行清空操作，字典级别的操作；
66 print(info)#{}空字典；
67 #info[‘alex‘:[24,‘IT‘],‘rain‘:[24,‘HR‘],‘jack‘:22]#    info[‘alex‘:[24,‘IT‘],‘rain‘:[24,‘HR‘],‘jack‘:22] TypeError: unhashable type: ‘slice‘
68 info = {‘alex‘:[24,‘IT‘],‘rain‘:[24,‘HR‘],‘jack‘:22}
69 print(info)
70 print(info.keys())#dict_keys([‘alex‘, ‘rain‘, ‘jack‘])
71 print(info.values())#dict_values([[24, ‘IT‘], [24, ‘HR‘], 22])
72 print(info.items())#dict_items([(‘alex‘, [24, ‘IT‘]), (‘rain‘, [24, ‘HR‘]), (‘jack‘, 22)])
73 dic2 = {1:2,2:3,‘jack‘:[22,‘Jack Ma‘,‘Alibaba CEO‘]}
74 print(info)#{‘alex‘: [24, ‘IT‘], ‘rain‘: [24, ‘HR‘], ‘jack‘: 22}
75 info.update(dic2)#类似于list中的extend方法，2个字典的间的拓展操作；
76 print(info)#{‘alex‘: [24, ‘IT‘], ‘rain‘: [24, ‘HR‘], ‘jack‘: [22, ‘Jack Ma‘, ‘Alibaba CEO‘], 1: 2, 2: 3}#如果有对应值就覆盖，没有则创建；
77 print(info.setdefault(2,‘New 2‘))#返回值3，如果有键2，则返回2的值；
78 print(info.setdefault(‘test‘,‘New 2‘))#返回值New 2，如有没有，则返回；
79 print(info)
80 print(info.fromkeys([‘A‘,‘B‘,‘C‘]))#{‘A‘: None, ‘B‘: None, ‘C‘: None}
81 print(info.fromkeys([‘A‘,‘B‘,‘C‘],‘alex‘))#{‘A‘: ‘alex‘, ‘B‘: ‘alex‘, ‘C‘: ‘alex‘}实际应用先生成空字典，再批量插入值；
82 #与list相似，dict也可以循环；
83 for k in info:
84     print(k)
85     print(k,info[k])#最常用的字典循环方法；
86 #下方不高能，不建议使用，效率是生产力的第一保障！
87 for k,v in info.items():#低效率，先把字典转化成列表，再循环遍历，拒绝使用吧！
88     print(k,v)

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/9 5:10
 5 iphone7 = [‘alex‘,‘rain‘,‘jack‘,‘old_driver‘]
 6 iphone8 = [‘alex‘,‘shanshan‘,‘jack‘,‘old_boy‘]
 7 both_list = []
 8 #如何找出同时买了IPhone7和8的人？！
 9 for name in iphone7:#先循环一个列表，嵌套；
10     if name in iphone8:
11         both_list.append(name)
12 print(both_list)#[‘alex‘, ‘jack‘]
13 #对比两个数据集合的操作-交集、差集、并集；
14 #集合的创建方式；
15 dic1 = {}#此处是字典；
16 print(type(dic1))#<class ‘dict‘>
17 print(type({}))#<class ‘dict‘>
18 dic2 = {1,2,3,4,5}#此处是集合；
19 print(type(dic2))#<class ‘set‘>,数据类型集合set
20 dic3 = {1,2,3,4,2,3,6}
21 print(dic3)#{1, 2, 3, 4, 6}集合自动去重；
22 lis1= [1,2,3,4,5,2,3]
23 print(lis1)#[1, 2, 3, 4, 5, 2, 3]
24 print(set(lis1))#{1, 2, 3, 4, 5}将列表转化为集合set；
25 print(type(set(lis1)))#<class ‘set‘>,能转化list和元组；
26 #集合的方法；
27 #增加；
28 dic4 = {1,2,3,4,5}
29 dic4.add(2)#增加一个已存在的值；
30 print(dic4)#{1, 2, 3, 4, 5}
31 dic4.add(6)#增加一个未存在的值；
32 print(dic4)#{1, 2, 3, 4, 5, 6}
33 #print(help(dic4.pop()))查看字典的帮助信息；
34 dic4.pop()#集合是无序的，随机删除一个元素,无索引的概念；
35 print(dic4)#随机删除一个元素后的结果输出{2, 3, 4, 5, 6}；
36 #删除集合中指定的元素；
37 dic4.remove(6)
38 print(dic4)#{2, 3, 4, 5}
39 #discard方法；类似于字典中的get方法；
40 #dic4.remove(6)#KeyError: 6,使用remove方法，删除集合中不存在的元素，会出现报错信息；
41 dic4.discard(6)#
42 print(dic4)#{2, 3, 4, 5}，使用discard方法，删除集合中不存在的元素，不会出现报错信息，一些场景推荐使用；
43 dic4.update([10,12,15,1,2,3,4,5])#往集合中拓展多个元素，add只能一次增加一个，类似于list中的extend方法和字典中的update方法；
44 print(dic4)#{1, 2, 3, 4, 5, 10, 12, 15}
45 #清空set中的内容；
46 dic4.clear()
47 print(dic4)#set()

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/9 5:39
 5 #取出交集；
 6 iphone7 = {‘alex‘,‘rain‘,‘jack‘,‘old_driver‘}
 7 iphone8 = {‘alex‘,‘jack‘,‘shanshan‘,‘old_boy‘}
 8 print(iphone7.intersection(iphone8))#{‘jack‘, ‘alex‘}，取出两者的交集；
 9 print(iphone7&iphone8)#{‘jack‘, ‘alex‘},此刻，&符号等价于intersection方法；
10 #取出差集；
11 print(iphone7.difference(iphone8))#{‘old_driver‘, ‘rain‘}，买了iphone7却没有买iPhone8的人；
12 print(iphone7-iphone8)
13 print(iphone8.difference(iphone7))#{‘shanshan‘, ‘old_boy‘},买了iphone8却没有买iPhone7的人；
14 print(iphone8-iphone7)；
15 #取出并集；
16 print(iphone8.union(iphone7))
17 print(iphone7.union(iphone8))
18 print(iphone7|iphone8)
19 print(iphone8|iphone7)
20 #以上4者等价{‘jack‘, ‘old_boy‘, ‘shanshan‘, ‘old_driver‘, ‘rain‘, ‘alex‘}，买了iphone7或者iPhone8的人
21 #对称差集-需求：取出两者不想交的部分，只买了iPhone7或iphone8的人；
22 s = {1,2,3,4}
23 s2 = {2,3,5,6}
24 print(s.symmetric_difference(s2))#{1, 4, 5, 6}
25 print(s2.symmetric_difference(s))#{1, 4, 5, 6}
26 print(iphone8.symmetric_difference(iphone7))
27 print(iphone7.symmetric_difference(iphone8))
28 #以上4者等价{‘old_driver‘, ‘shanshan‘, ‘old_boy‘, ‘rain‘}，买了iphone7或者iPhone8的人
29 #子集和超集；
30 s2.add(1)
31 s2.add(4)
32 print(s2)#{1, 2, 3, 4, 5, 6}
33 print(s)#{1, 2, 3, 4}
34 print(s.issubset(s2))#True,判断集合是不是被其他集合包含,等同于 s <=s2；
35 print(s.issuperset(s2))#Flase判断集合是不是包含其他集合,等同于 s >=s2；
36 print(s2.issubset(s))#Flase；
37 print(s2.issuperset(s))#True；
38 #超集和子集可以使用> 或<符号；
39 #如果集合中的数据量特别大，可以使用s.isdisjoint()判断是否不相交；
40 print(s.isdisjoint(s2))#False；
41 print(s2.isdisjoint(s))#False,返回False说明二者相交；
42 s3 = {1,2,3,4,-1,-2}
43 s4 = {1,2,3,4,5,6}
44 s3.difference_update(s4)#将s3与s4差集的结果赋值给s3，{-2, -1}
45 print(s3)
46 # s4.difference_update(s3)
47 # print(s4)
48 
49 s3 = {1,2,3,4,-1,-2}
50 s4 = {1,2,3,4,5,6}
51 s3.intersection_update(s4)#不常用，把交集的结果赋值给s3，{1, 2, 3, 4}
52 print(s3)
53 
54 
55 s3 = {1,2,3,4,-1,-2}
56 s4 = {1,2,3,4,5,6}
57 s4.intersection_update(s3)#不常用，把交集的结果赋值给s4，{1, 2, 3, 4}
58 print(s4)

 1 #! /usr/bin/env python
 2 # -*- coding:utf-8 -*-
 3 #__author__ = "tqtl"
 4 # Date:2018/5/9 6:14
 5 
 6 #10进制转换8、16进制的语法
 7 print(oct(1))#0o1   10进制转换8进制，以0o开头，逢7进1
 8 print(oct(2))#0o2
 9 print(oct(3))#0o3
10 print(oct(7))#0o7
11 print(oct(8))#0o10
12 print(oct(64))#0o100
13 print(‘-------------------‘)
14 print(hex(1))#0x1   10进制转换16进制，以0x开头，逢16进1
15 print(hex(3))#0x3
16 print(hex(9))#0x9
17 print(hex(10))#0xa
18 print(hex(11))#0xb
19 print(hex(15))#0xf
20 print(hex(16))#0x10
21 print(hex(1115))#0x45b