1. 格式字符串

%s, %d, %.2f, %c

name = '喜爱'
age = 18
message = name + '今年' + str(age) + '岁'
message = '%s今年%d %c' % (name, age, 0xe4ff)
print(message)

# 2.列表(list)
# 可变（支持增删改）、有序(支持下标操作)
# 列表中元素的增删改查
# 1)查： 查单个元素: 列表[下标]  - 结果是元素     切片：列表[开始下标:结束下标:步长]  - 是列表
#      遍历 - 结果是元素
# 2)增: 列表.append(元素) \  列表.insert(下标, 元素)
# 3)删: del 列表[下标]   \  列表.remove(元素)   \  列表.pop(下标)
# 4)改: 列表[下标] = 新值
list1 = [1, 2, 3]  # [100, 200, 300]
# list1.remove(1)
# print(list1)
# print(list1.remove(1))  # null NULL Null
print(list1)

1.列表相关运算

1)数学运算: +, *
列表1+列表2 - 将两个列表中的元素合并产生一个新的列表（原列表不会发生改变）
列表*N - 列表中的元素重复N次产生新的列表

list1 = [1, 2, 3]
list2 = ['name', 'age']
new_list = list1 + list2
print(new_list, list1, list2)
print(list1*3)
list3 = [1]*100
print(list3)

# 2)比较运算: ==, !=
list4 = [1, 2]
print([1, 2] == [2, 1])  # False
print([1, 2] != [2, 1])  # True
print([1, 2] == list4)   # True

# >, <, >=, <= 只支持相同位置上元素类型相同的两个列表  (了解)
print([1, '2', 3] > [100, 'z'])
# print([1, 2, 3] > ['a', 'b'])   #TypeError: '>' not supported between instances of 'int' and 'str'

2.内置函数

len(列表)、sum(列表) - 要求列表中的元素必须是数字、max(列表)、min(列表)
list(数据) - 将指定数据转换成列表, 所有的序列都可以转换成列表,比如: 字符串，列表、字典、集合、元祖、range、迭代器、生成器等
转换的时候是将序列中的元素作为列表元素

# print(sum(['1', 'abc', 'hj']))
# print(max([1, 'a']))

print(list('abcd'))
print(list(range(5)))
print(list(str(123)))

nums = ['10', '23', '4']   # 10234
print(''.join(nums))

3.相关方法

1. 列表.count(元素) - 获取指定元素在列表中出现的次数, 结果是整数
  print([1, 2, 3, 1, 4].count(1))
1. 列表.extend(序列) - 将序列中的元素添加到列表中, 结果None

list1 = []
list1.extend('abc')
print(list1)
list1.extend(range(3))
print(list1)
list1.extend(['张飞', '关羽', '赵云'])
print(list1)

list1.extend(['吕布'])
print(list1)

3)列表.index(元素) - 获取指定元素在列表中的下标，如果这个元素有多个只获取第一个，如果元素不存在会报错

list2 = [1, 0, 1, 2, '张飞', '关羽', '赵云', '吕布']
print(list2.index('张飞'))
# print(list2.index('诸葛亮'))    # ValueError: '诸葛亮' is not in list

4)列表.reverse() - 将列表中的元素倒序, 不会产生新列表
list2.reverse()
print(list2)

补充: 内置函数: reversed(序列) - 将序列中的元素倒序产生一个新的迭代器，原序列不会修改

list1 = [1, 2, 3]
result = reversed('abc')
# for item in result:
#     print(item)
print(list(result))
print(list1)

5)列表.sort() - 对列表中的元素从小到大排序(列表中的元素类型一致并且支持比较运算), 不会产生新的列表


# 列表.sort(reverse=True)   -  从大到小排序
scores = [10, 100, 89, 20, 67, 34, 9]
# scores.sort()
# print(scores)      # python cookbook/ 流畅的python

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

6)列表.copy() - 产生一个新的列表，列表中的元素和原列表一样，相当于：列表[:]

list1 = [1, 2, 3]
list2 = list1
list3 = list1.copy()
print(list2, list3)

list1.append(10)
print(list2, list3)

id(变量) - 查看变量中实质存储的地址

python所有变量实质都是直接保存的数据在内存中的地址

print(id(list1), id(list2), id(list3))

！！！解决列表删除问题：删不干净和越界！！！

# 列表中删除数据
# 删除列表中所有小于60的数字


# 问题1: 通过元素删除的时候可能出现删不干净的问题
# 删除的时候遍历原列表，删除原列表，再把遍历的删除
scores = [10, 50, 90, 89, 45, 70]
for score in scores:
    if score < 60:
        scores.remove(score)# 删除列表指定的元素

print(scores, score)    # [50, 90, 89, 20, 70]

"""
scores = [10, 50, 90, 89, 45, 70]
score = 10   if 10 < 60    scores.remove(10)   scores = [50, 90, 89, 45, 70]  
score = 90   if 90 < 60
score = 89   if 89 < 60
score = 45   if 45 < 60    scores.remove(45)   scores = [50, 90, 89, 70] 
"""

# 解决问题1：
scores = [10, 50, 90, 89, 45, 70]
scores2 = scores[:]
for score in scores2:
    if score < 60:
        scores.remove(score)
del scores2    # score2只是提供遍历用的，用完后没有其他用处，可以直接删除
print(scores, score)


# 上面的简写
scores = [10, 50, 90, 89, 45, 70]
for score in scores[:]:
    if score < 60:
        scores.remove(score)
print(scores, score)
"""
scores = [10, 50, 90, 89, 45, 70]
scores2 = [10, 50, 90, 89, 45, 70]
score = 10   if 10<60  scores.remove(10)   scores = [50, 90, 89, 45, 70]
score = 50   if 50<60  scores.remove(50)   scores = [90, 89, 45, 70]
score = 90   if 90<60
score = 89   if 89<60
score = 45   if 45<60  scores.remove(45)   scores = [90, 89,70]
score = 70   if 70<60
"""


# 问题2：通过下标删除满足要求的元素的时候，出现下标越界的错误
print('====================问题2=====================')
# scores = [10, 50, 90, 89, 45, 70]
# for index in range(len(scores)):
#     if scores[index] < 60:
#         del scores[index]
#
# print(scores)
"""
scores = [10, 50, 90, 89, 45, 70]
for index in range(6)  
index = range(6)  index = (0,1,2,3,4,5)
index = 0   if scores[0]<60   if 10<60   del scores[0]  scores = [50, 90, 89, 45, 70]
index = 1   if scores[1]<60   if 90<60   
index = 2   if scores[2]<60   if 89<60
index = 3   if scores[3]<60   if 45<60   del scores[3]  scores = [50, 90, 89, 70]
index = 4   if scores[4]<60  (out of range)
"""
# 解决问题2:
scores = [10, 50, 90, 89, 45, 70]
index = 0
while index < len(scores):
    if scores[index] < 60:
        del scores[index]
        continue
    index += 1

print(scores)
"""
scores = [10, 50, 90, 89, 45, 70]   
index = 0
while 0 < 6    if 10<60   del scores[0]   scores = [50, 90, 89, 45, 70] 
while 0 < 5    if 50<60   del scores[0]   scores = [90, 89, 45, 70]
while 0 < 4    if 90<60   index += 1  index = 1
while 1 < 4    if 89<60   index += 1  index = 2
while 2 < 4    if 45<60   del scores[2]   scores = [90, 89,70]
while 2 < 3    if 70<60   index += 1  index = 3  
while 3 < 3 
print(scores)  -  [90, 89,70] 
"""

1.什么是元祖(tuple):

元祖就是不可变的列表, 作为序列不可变(不支持增删改)但是有序(支持下标操作)
(元素1, 元素2, 元素3,....) , 元素的要求和列表一样

2.查 - 获取元素 (和列表一样)

tuple1 = ('abc', 2, 3, 4)
print(tuple1[0], tuple1[-1])
# print(tuple1[10])   # IndexError: tuple index out of range
print(tuple1[0:5:2])
for item in tuple1:
    print(item)

for index in range(len(tuple1)):
    print(index, tuple1[index])

3.数学运算、比较运算、in/not in、 len(), max(), min(), sum(), tuple()和对应的列表操作是一样的

print((1, 2, 3)+('a', 'b', 'c'))
print((1, 2, 3) * 2)
print(100 in (1, 2, 3))
print(tuple('abcd'), tuple(range(4)), tuple(['abc', 100]))

4.元祖专有特点

1)只有一个元素的元祖, 需要在这个元素的后面加一个逗号

tu1 = ('abc',)
print(type(tu1))

2)元祖的值可以去掉小括号，(直接将多个元素用逗号隔开，也表示一个元祖)

tu2 = 10, 20, 30, 'abc'
print(tu2, type(tu2))

3) 让变量的个数和元祖中元素的个数保持一致，可以让变量依次取出元祖的中的元素

point = (100, 200)
x, y = point
print(x, y)

x, y = (100, 200)
x, y = 100, 200

a = 10
b = 20
a, b = (b, a)       # a, b = (b,a) = (20, 10)  a = 20, b=10

3.2) 通过多个变量去获取元祖元素的时候，可以在某个变量的前面加来将这个变量变成列表获取不带的变量取剩下的数据

注意：这儿带*的变量只能有一个

student = ('小明', 30, 60, 50, 100, 175)
name, age, *scores, height = student
print(name, scores)

name, *x = student
print(name, x)

*x, y, z = student
print(x, y)

1.什么是字典(dict)

字典是python内置的一个容器型数据类型, 可变(支持增删改)、无序(不支持下标操作)
{键1:值1, 键2:值2, 键3:值3,....} 键:值 -> 键值对
键(key): a.不可变 b.唯一 (实际开发建议用字符串)
值(value): 和列表元素的要求一样
注意: 键值对是成对出现；字典存数据，实质要存的是值，键是值的索引

dict1 = {'a': 100, 'b': 'abc', 'c': [1, 2], 'd': {'a': 100}}
print(dict1)

dict1 = {'a': 100, 'b': 'abc', 'a': [1, 2]}
print(dict1)   # {'a': [1, 2], 'b': 'abc'}

2.什么时候用字典

如果同时保存的多个数据是具有相同意义的数据，用列表；如果同时保存的多个数据的意义不同，就使用字典

person1 = ['余婷', 18, 100, 40, 155, 50]
person2 = {'name': '余婷', 'age': 18, 'score': 100, 'height': 155, 'weight': 50}
print(person1[0])
print(person2['name'])

allstudents = [
                {'name': '张三', 'age': 18, 'tel': '110', 'dog':{'sex': '母狗', 'color': '白色', 'name': '大黄'}},
                {'name': '小明', 'age': 20, 'tel': '220'},
                {'name': '张三', 'age': 18, 'tel': '110'}
               ]

print(allstudents[0]['dog']['color'])

3.查 - 获取字典的值

1. 获取key对应的值: 字典[key] - 获取字典中指定key对应的值
注意: 如果key不存在，会报KeyError

dog1 = {'name': '大黄', 'type': '中华田园犬', 'color': 'yellow', 'age': 3}
print(dog1['type'])
# print(dog1['gender'])    # KeyError: 'gender'

# 获取key对应的值:
# 字典.get(key)  - 获取字典中指定key对应的值, 如果key值不存在返回默认值None
# 字典.get(key, 默认值)  - 获取字典key对应的值，如果key不存在返回指定的默认值
# None是python中的关键字,表示数据为空或者没有的意思
print(dog1.get('color'))
print(dog1.get('gender'))
print(dog1.get('gender', '公狗'))

2)遍历

直接遍历字典拿到是key

dog1 = {'name': '大黄', 'type': '中华田园犬', 'color': 'yellow', 'age': 3}
print('===========遍历===========')
for key in dog1:
    print(key, dog1[key])

!!!遍历字典选第一种方法，后面的方法要看得懂!!!

print('===========遍历2===========')
print(dog1.values())
for value in dog1.values():
    print(value)

print('===========遍历3===========')
for key in dog1.keys():
    print(key)

print('===========遍历4===========')
print(dog1.items())
for key, value in dog1.items():
    print(key, value)

4.增/改 - 添加键值对

字典[key] = 值 - 当key不存在的时候就是添加键值对；当key存在的时候，就是修改key对应的值

film = {'name': '流浪地球', '主演': '吴京', 'time': '2019-2-5'}
film['票房'] = '40亿'
print(film)

film['time'] = '2019-2-6'
print(film)

film.setdefault('a', 10)
print(film)

字典.setdefault(key, value) - 只能增加键值对，不能修改

film.setdefault('name', '战狼2')
print(film)

5.删

del 字典[key] - 删除字典中key对应的键值对, 如果key不存在会报错

film = {'name': '流浪地球', '主演': '吴京', 'time': '2019-2-5'}
del film['time']
print(film)

字典.pop(key) - 从字典中取出key对应的值，结果是key对应的值

name = film.pop('name')
print(film, name)

6.相关运算

只支持比较运算符

print({'a': 10, 'b': 20} == {'b': 20, 'a': 10})    # True

in / not in

key in 字典 - 判断字典中是否存在某个key对应的键值对

student = {'name': '小明', 'age': 20, 'tel': '16362738493'}
print('小明' in student)   # False
print('name' in student)    # True

len(), max(), min()
dict() - 本身是一个序列，序列中元素是小序列，小序列必须有且只有2个元素，而且这个2个元素中的第一个元素是不可变的

注意：取最大值最小值是取key的最大值和最小值;字典转列表/元祖的时候，是将字典的key取出来作为列表/元祖的元素

print(len(student))
print(max(student))
print(dict(['cb', ['a', 100],  [1000, [1]] ]))
print(list(student))

7.相关方法

1)字典.clear() - 清空字典

student.clear()
print(student)

2)字典.copy() - 复制字典的内容，产生一个新的字典

student = {'name': '小明', 'age': 20, 'tel': '16362738493'}
student1 = student.copy()
student1['name'] = '小花'
print(student)

1. dict.fromkeys(序列,值) - 创建一个新的字典，将序列中的元素作为新字典的key,指定的值作为每个key对应的值

new_dict = dict.fromkeys(['name', 'age', 'gender'], None)
print(new_dict)

person_keys = ['name', 'age', 'gender']
person1 = dict.fromkeys(person_keys, None)
person2 = dict.fromkeys(person_keys, None)

1. 字典1.update(字典2) - 将字典2中的键值对添加到字典1中

dict1 = {'a': 10, 'b': 20, 'z': 100}
dict1.update({'c': 30, 'b': 200})
print(dict1)

day8-recode

1. 格式字符串

1.列表相关运算

2.内置函数

3.相关方法

补充: 内置函数: reversed(序列) - 将序列中的元素倒序产生一个新的迭代器，原序列不会修改

5)列表.sort() - 对列表中的元素从小到大排序(列表中的元素类型一致并且支持比较运算), 不会产生新的列表

id(变量) - 查看变量中实质存储的地址

python所有变量实质都是直接保存的数据在内存中的地址

！！！解决列表删除问题：删不干净和越界！！！

1.什么是元祖(tuple):

2.查 - 获取元素 (和列表一样)

3.数学运算、比较运算、in/not in、 len(), max(), min(), sum(), tuple()和对应的列表操作是一样的

4.元祖专有特点

1)只有一个元素的元祖, 需要在这个元素的后面加一个逗号

2)元祖的值可以去掉小括号，(直接将多个元素用逗号隔开，也表示一个元祖)

3) 让变量的个数和元祖中元素的个数保持一致，可以让变量依次取出元祖的中的元素

3.2) 通过多个变量去获取元祖元素的时候，可以在某个变量的前面加来将这个变量变成列表获取不带的变量取剩下的数据

注意：这儿带*的变量只能有一个

1.什么是字典(dict)

2.什么时候用字典

3.查 - 获取字典的值

2)遍历

!!!遍历字典选第一种方法，后面的方法要看得懂!!!

4.增/改 - 添加键值对

字典.setdefault(key, value) - 只能增加键值对，不能修改

5.删

6.相关运算

只支持比较运算符

in / not in

注意：取最大值最小值是取key的最大值和最小值;字典转列表/元祖的时候，是将字典的key取出来作为列表/元祖的元素

7.相关方法

你可能感兴趣的:(day8-recode)

day8-recode

1. 格式字符串

1.列表相关运算

2.内置函数

3.相关方法

补充: 内置函数: reversed(序列) - 将序列中的元素倒序产生一个新的迭代器， 原序列不会修改

5)列表.sort() - 对列表中的元素从小到大排序(列表中的元素类型一致并且支持比较运算), 不会产生新的列表

id(变量) - 查看变量中实质存储的地址

python所有变量实质都是直接保存的数据在内存中的地址

！！！解决列表删除问题：删不干净和越界！！！

1.什么是元祖(tuple):

2.查 - 获取元素 (和列表一样)

3.数学运算、比较运算、in/not in、 len(), max(), min(), sum(), tuple()和对应的列表操作是一样的

4.元祖专有特点

1)只有一个元素的元祖, 需要在这个元素的后面加一个逗号

2)元祖的值可以去掉小括号，(直接将多个元素用逗号隔开，也表示一个元祖)

3) 让变量的个数和元祖中元素的个数保持一致，可以让变量依次取出元祖的中的元素

3.2) 通过多个变量去获取元祖元素的时候，可以在某个变量的前面加来将这个变量变成列表获取不带的变量取剩下的数据

注意：这儿带*的变量只能有一个

1.什么是字典(dict)

2.什么时候用字典

3.查 - 获取字典的值

2)遍历

!!!遍历字典选第一种方法，后面的方法要看得懂!!!

4.增/改 - 添加键值对

字典.setdefault(key, value) - 只能增加键值对，不能修改

5.删

6.相关运算

只支持比较运算符

in / not in

注意：取最大值最小值是取key的最大值和最小值;字典转列表/元祖的时候，是将字典的key取出来作为列表/元祖的元素

7.相关方法

你可能感兴趣的:(day8-recode)

补充: 内置函数: reversed(序列) - 将序列中的元素倒序产生一个新的迭代器，原序列不会修改