python基础

列表进阶和元组级字典基础

相关函数

1.max,min - 最大值，最小值

max(序列)

1
2
nums = [88,99,76,80,89,66]
print(max(nums),min(nums))

2.sum - 求数字序列中元素的和

1
2
nums = [88,99,76,80,89,66]
print(sum(nums))

3.sorted - 排序 降序(sorted(序列,reverse=True))

sorted(序列)

1
2
3
4
nums = [88,99,76,80,89,66]
new_nums = sorted(nums)
print(nums)
print(new_nums)

4.列表.sort()

1
2
3
4
nums = [88,99,76,80,89,66]
result = nums.sort()  
print(nums)
print(result)   #None

5.len - 获取序列中元素的个数

#len(序列)

1
2
nums = [88,99,76,80,89,66]
print(len(nums))

5.list - 列表类型转换

list(序列) - 所有的序列都可以转换成列表；转换的时候直接将序列中的元素转换成列表的元素

1
2
print(list('abc'))
print(list(range(3)))

列表推导式 - 本质就是创建列表的表达式(简介)

结构一

1
2
结构一:
[表达式 for 变量 in 序列]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
list1 = [10 for x in range(4)]
print(list1)  ##[10, 10, 10, 10]

list2 = [x for x in range(4)]
print(list2)  ##[0, 1, 2, 3]

list3 = [x*2+1 for x in range(4)]
print(list3)  ##[1, 3, 5, 7]

scores = [89,67,65,98,53,49]
list4 = [x % 10 for x in scores]
print(list4)  ##[9, 7, 5, 8, 3, 9]

list5 = [x >=60 for x in scores]
print(list5)  ##[True, True, True, True, False, False]

结构二

1
2
结构二:
[表达式 for 变量 in 序列 if 条件语句]
1
2
3
4
5
6
7
8
9
list7 = [10 for x in range(4) if x % 2]
print(list7)  ##[10, 10]

list8 = [x for x in range(4) if x % 2]
print(list8)  ##[1, 3]

scores = [89,67,65,98,53,49]
list9 = [x for x in scores if x >= 60]
print(list9)  ##[89, 67, 65, 98]

列表推导式的应用

应用1:让序列中所有的元素进行统一变换

[表达式 for 变量 in 序列]

练习1.[89,67,34,56,10,90] -> [[0,89],[1,67],…]

1
2
3
nums = [89,67,34,56,10,90]
new_nums=[[x,nums[x]] for x in range(len(nums))]
print(new_nums)

应用2:将序列中满足某个条件的元素进行变换

(根据某个条件是否满足做两种不同的变换)

[表达式 for 变量 in 序列 if 条件语句]

练习2.将nums中所有偶数除以2

1
2
3
nums = [89,67,34,56,10,90]
new_nums=[x if x % 2 else int(x/2) for x in nums]
print(new_nums)

应用3.提取序列中满足某个条件的元素(提取,删除)

练习3:删除所有的偶数(提取所有的奇数)

[89,67,34,56,10,90,35] -> [89,67,35]

1
2
3
4
nums = [89,67,34,56,10,90,35]
new_nums=[x for x in nums if x % 2]
print(new_nums)
print(nums)

补充：三目运算符：

exp1 if contion else exp2

1
2
3
4
5
6
7
age = 38
# if age>=18:
#     a = "成年"
# else:
#     a = "未成年"
a = "成年" if age>=18 else "未成年"
print(a)

元组() tuple

1.元组是容器型数据类型,()作为容器的标志,里面多个元素用逗号隔开

2.元组不可变;只能作查操作;元组有序-支持下标操作

3.对元素没有要求

1
2
t1 = ()
print(type(t1),len(t1))

只有一个元素的元组

重点:唯一的元素后面必须加逗号,否则就不是元组

1
2
3
4
5
6
7
8
list1 = []
print(list1,type(list1),len(list1)) ##[] <class 'list'> 0

t2 = (12)
print(t2,type(t2))  ##12 <class 'int'>

t3 = (12,)
print(t3,type(t3))  ##(12,) <class 'tuple'>

在没有歧义的情况下，元组的小括号可以省略(直接将多个数据用多个逗号隔开)

1
2
3
4
t5 = (10,20,30)
t6 = 10,20,30
print(t5,type(t5))  ##(10, 20, 30) <class 'tuple'>
print(t6,type(t6))  ##(10, 20, 30) <class 'tuple'>

查 - 获取元素

1.列表获取元素的方式元组都支持

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
nums = (45,90,23,62,78)
print(nums[1],nums[-5])

print("-"*20)

for item in nums:
    print(item)

print("-"*20)

for index,item in enumerate(nums):
    print(index,item)

print("-"*20)

print(nums[:])
print(nums[::-1])

2.通过变量获取元组的元素(1) - 让变量的个数和元组的元素保存一致

1
2
3
point = (10,20,30)
x,y,z = point  ## x,y,z =10,20,30
print(x,y,z)   ## 10 20 30

2.通过变量获取元组的元素(2) -

如果变量的个数小于元素的个数,必须在其中一个变量前加*

取的时候先让没有的变量按位置关系获取元素，剩下的全部给带的变量

1
2
3
4
5
6
7
8
9
10
11
12
info = ('张三',18,175,65,86,99)
name,age,*other = info
print(name,age)  ## 张三 18
print(name,age,other)  ## 张三 18 [175, 65]
name,age,*other,mathd = info
print(name,age,other,mathd)  ##张三 18 [175, 65, 86] 99

x,*y,z,m = info
print(x,z,m)

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

3.元组是不可变的列表 - 列表中不可变的相关操作元组都支持

不支持sort,支持sorted

1
2
3
4
5
6
7
8
9
aa = (1,6,8,7,5,9,4,3)
print((1,2,3)+(4,5,6))
print(1 in (1,2,3,4))
print((1,2,1,3,1,4).count(1))
print(max((1,2,3,4,5,6)))

# bb = aa.sort()  ##报错
cc = sorted(aa)
print(cc)  ##[1, 3, 4, 5, 6, 7, 8, 9]

字典 - dict {}

1.实例

1
2
3
4
5
6
7
stu = {
    'name':'小明',
    'age': 18,
    'sex':'男',
    '体重':65
}
print(stu,type(stu))  ##{'name': '小明', 'age': 18, 'sex': '男', '体重': 65} <class 'dict'>

2.什么是字典

2.1字典是容器型数据,将{}作为容器标志,里面多个键值对用逗号隔开

{键1:值1,键2:值2} 成对出现

字典是可变的(支持增删改);字典是无序的(不支持下标操作)

字典元素是键值对

键 - 键必须是不可变的数据(数字,字符串,元组) 键是唯一的

值 - 没有要求

2.2空字典

1
2
d1 = {}
print(type(d1),len(d1))

2.2 键是不可变的数据

1
2
3
4
d2 = {1:10,'a':20,(10,20):30}
print(d2)

## d3 = {1:10,'a':20,[10,20]:30} #键使用列表，列表可变，报错

2.3 键是唯一的

1
2
d4 = {'a':10,'b':20,'c':30,'b':40}
print(d4)  ##{'a': 10, 'b': 40, 'c': 30} 其中'b':20丢失

2.4字典是无序的

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

2.5字典的增删改查

2.5.1 查 - 获取字典的值

1)获取单个值 字典[键]

1
2
3
4
5
6
7
dog = {'name':'小黄','age':3,'breed':'土狗','color':'white'}
print(dog['name'])
print(dog.get('name'))

## print(dog['height'])  ##报错 键不存在
print(dog.get('height')) ##None
print(dog.get('height',0))  ##如果键不存在返回0

2)遍历 - 一次遍历取的是键

1
2
for 变量 in 字典:
    循环体
1
2
3
dog = {'name':'小黄','age':3,'breed':'土狗','color':'white'}
for key in dog:
    print(key,dog[key])   ## 取的是键

2.5.2 实际应用中的字典和列表

定义一个变量保存一个班级信息

1
2
3
4
5
6
7
8
9
10
11
12
13
class1 = {
    'name': 'python2104',
    'address': '23教',
    'lecturer': {'name': '余婷', 'age': 18, 'QQ': '726550822'},
    'leader': {'name': '舒玲', 'age': 18, 'QQ': '2343844', 'tel': '110'},
    'students': [
        {'name': 'stu1', 'school': '清华大学', 'tel': '1123', 'linkman': {'name': '张三', 'tel': '923'}},
        {'name': 'stu2', 'school': '攀枝花学院', 'tel': '8999', 'linkman': {'name': '李四', 'tel': '902'}},
        {'name': 'stu3', 'school': '成都理工大学', 'tel': '678', 'linkman': {'name': '小明', 'tel': '1123'}},
        {'name': 'stu4', 'school': '四川大学', 'tel': '9900', 'linkman': {'name': '小花', 'tel': '782'}},
        {'name': 'stu5', 'school': '西南交大', 'tel': '665', 'linkman': {'name': '老王', 'tel': '009'}}
    ]
}

1)获取班级名称

1
print(class1['name'])

2)获取讲师QQ

1
print(class1['lecturer'].get('QQ'))

3)获取所有学生的名字和学校

1
2
for item in class1['students']:
    print(item['name'],item['school'])

4)获取所有学生的联系人的电话

1
2
for i in class1['students']:
    print(i['linkman'].get('tel'))

作业

1.创建一个列表，列表中有10个舒宗, 保证列表中元素的顺序，对列表进行排重,并对列表使用进行降序排序

1
2
3
例如：随机生成了[70, 88, 91, 70, 107, 234, 91, 177, 282, 197]
		--- 去重之后 [70, 88, 91, 107, 234, 177, 282, 197]
  	---- 降序排序 [282, 234, 197, 177, 107, 91, 88, 70]
1
2
3
4
5
6
list1 = [70, 88, 91, 70, 107, 234, 91, 177, 282, 197]
new_names=[]
for index in range(len(list1)):
    if list1[index] not in new_names:
        new_names.append(list1[index])
print(sorted(new_names,reverse=True))

2.利用列表推导式, 完成以下需求

a. 生成一个存放1-100中各位数为3的数据列表

1
结果为 [3, 13, 23, 33, 43, 53, 63, 73, 83, 93]
1
2
list2 = [x for x in range(100) if x % 10 ==3]
print(list2)

b. 利用列表推到是将 列表中的整数提取出来

1
例如：[True, 17, "hello", "bye", 98, 34, 21] --- [17, 98, 34, 21]
1
2
3
list3 = [True, 17, "hello", "bye", 98, 34, 21]
list4 = [item for item in list3 if type(item) == int]
print(list4)

c.利用列表推导式 存放指定列表中字符串的长度

1
例如 ["good", "nice", "see you", "bye"] --- [4, 4, 7, 3]
1
2
3
list5 = ["good", "nice", "see you", "bye"]
list6 = [len(item) for item in list5]
print(list6)

4.已经一个班级字典如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class1 = {
    'name': 'python2104',
    'address': '23教',
    'lecturer': {'name': '余婷', 'age': 18, 'QQ': '726550822'},
    'leader': {'name': '舒玲', 'age': 18, 'QQ': '2343844', 'tel': '110'},
    'students': [
        {'name': 'stu1', 'school': '清华大学', 'tel': '1123', 'age': 18, 'score': 98, 'linkman': {'name': '张三', 'tel': '923'}},
        {'name': 'stu2', 'school': '攀枝花学院', 'tel': '8999', 'age': 28, 'score': 76, 'linkman': {'name': '李四', 'tel': '902'}},
        {'name': 'stu3', 'school': '成都理工大学', 'tel': '678', 'age': 20, 'score': 53, 'linkman': {'name': '小明', 'tel': '1123'}},
        {'name': 'stu4', 'school': '四川大学', 'tel': '9900', 'age': 30, 'score': 87, 'linkman': {'name': '小花', 'tel': '782'}},
        {'name': 'stu5', 'school': '西南交大', 'tel': '665', 'age': 22, 'score': 71, 'linkman': {'name': '老王', 'tel': '009'}},
        {'name': 'stu6', 'school': '成都理工大学', 'tel': '892', 'age': 32, 'score': 80, 'linkman': {'name': '老王2', 'tel': '0091'}},
        {'name': 'stu7', 'school': '四川大学', 'tel': '431', 'age': 17, 'score': 65, 'linkman': {'name': '老王3', 'tel': '0092'}},
        {'name': 'stu8', 'school': '攀枝花学院', 'tel': '2333', 'age': 16, 'score': 32, 'linkman': {'name': '老王4', 'tel': '0093'}},
        {'name': 'stu9', 'school': '攀枝花学院', 'tel': '565', 'age': 21, 'score': 71, 'linkman': {'name': '老王5', 'tel': '0094'}}
    ]
}

1获取班级位置

1
print("班级地址是：",class1['address'])

2）获取班主任的名字和电话

1
print(class1['leader']['name'],class1['leader']['tel'])

3）获取所有学生的姓名和分数

1
2
for item in class1['students']:
    print(item['name'],item['score'])

4）获取所有学生联系人的名字和电话

1
2
for i in class1['students']:
    print(i['linkman']['name'],i['linkman']['tel'])

5）获取班级最高分

1
2
3
4
5
max_scores = 0
for item in class1['students']:
    if item['score']>max_scores:
        max_scores = item['score']
print("班级最高分是：",max_scores)

6）获取班级分数最高的学生的姓名

1
2
3
4
5
6
7
max_scores = 0
name1 = 'aa'
for item in class1['students']:
    if item['score']>max_scores:
        max_scores = item['score']
        name1 = item['name']
print("最高分的名字是：",name1)

7）计算班级学生的平均分

1
2
3
4
5
6
count =0
sum1 = 0
for item in class1['students']:
    sum1+=item['score']
    count+=1
print("平均分为：",sum1/count)

8）统计班级中未成年人数

1
2
3
4
5
count = 0
for item in class1['students']:
    if item['age']<18:
        count+=1
print("未成年人数为：",count)

9）用字典统计每个学校的人数, 类似: {'清华大学': 1, '攀枝花学院': 3}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
aa = []
for item in class1['students']:
    aa.append(item['school'])
aa_new = []
for i in aa:
    if i not in aa_new:
        aa_new.append(i)
bb = []
for j in aa_new:
    bb.append(aa.count(j))
cc = {}
for k in range(len(aa_new)):
    cc[aa_new[k]] = bb[k]
print(cc)
python基础

列表操作

列表(list)

1.切片 - 获取部分元素(切片结果是列表)

1.1语法: 列表[开始下标:结束下标:步长]

1.2说明：

1.2.1开始和结束下标确定切片范围([开始下标,结束下标))

1.2.2步长决定切片方向(开始到结束的方向要和步长的方向保持一致)

1.2.3步长为正就是正向，否则就是反向

1.2.4同时步长还决定是一个一个取还是跳着取

1.2.5从负的开始下标到正的结束下标时必须要确定步长的方向

1.3省略步长,默认步长就是1

1
2
3
4
5
6
7
8
9
10
games = ['王者荣耀','和平精英','超级玛丽','穿越火线','英雄联盟']
print(games[-1:-5:-1])  ##['英雄联盟', '穿越火线', '超级玛丽', '和平精英']
print(games[::])  ##['王者荣耀', '和平精英', '超级玛丽', '穿越火线', '英雄联盟']
print(games[0:-1]) ##['王者荣耀', '和平精英', '超级玛丽', '穿越火线']
print(games[0:-1:1]) ##['王者荣耀', '和平精英', '超级玛丽', '穿越火线']
print(games[0:-1:2])  ##['王者荣耀', '超级玛丽']
print(games[-1:0])  ##[]
print(games[-1:0:1])  ##[]
print(games[-1:0:-1]) ##['英雄联盟', '穿越火线', '超级玛丽', '和平精英']
print(games[-1:0:-2])  ##['英雄联盟', '超级玛丽']

1.4省略开始下标 列表[:结束下标:步长] - 列表[:结束下标]

1.4.1省略开始下标，步长为正，从第一元素往后取，步长为负，从最后一个元往前取

1
2
3
games = ['王者荣耀','和平精英','超级玛丽','穿越火线','英雄联盟']
print(games[:3])  ##['王者荣耀', '和平精英', '超级玛丽']
print(games[:3:-1])  ##['英雄联盟']

1.5省略结束下标 列表[开始下标::步长] - 列表[开始下标:]

1.5.1省略结束下标，如果步长为正，从开始下标到最后一个元素，步长为负，从开始下标取到第一个元素

1
2
3
4
games = ['王者荣耀','和平精英','超级玛丽','穿越火线','英雄联盟']
print(games[1::])  #['和平精英', '超级玛丽', '穿越火线', '英雄联盟']
print(games[1::-1])  #['和平精英', '王者荣耀']
print(games[-1::-1])  #['英雄联盟', '穿越火线', '超级玛丽', '和平精英', '王者荣耀']

1.6同时省略开始下标和结束下标 列表[::步长] - 列表[:]

1.6.1用步长确定方向

1
2
3
games = ['王者荣耀','和平精英','超级玛丽','穿越火线','英雄联盟']
print(games[:]) ##['王者荣耀', '和平精英', '超级玛丽', '穿越火线', '英雄联盟']
print(games[::-1])  #['英雄联盟', '穿越火线', '超级玛丽', '和平精英', '王者荣耀']

2.删 - 删除列表元素(让列表元素个数减少)

2.1 删除一个元素

2.1.1 del 列表[下标] - 删除列表中指定下标对应的元素

下标不能越界

1
2
3
teleplays = ['海上繁花','你微笑时很美','九千米爱情','回家的诱惑', '康熙王朝', '破产姐妹', '亮剑']
del teleplays[3]
print(teleplays)

2.1.2 列表.remove(元素) 删除列表中的指定元素

1
2
3
teleplays = ['海上繁花','你微笑时很美','九千米爱情','回家的诱惑', '康熙王朝', '破产姐妹', '亮剑']
teleplays.remove('回家的诱惑')
print(teleplays)

如果元素不存在,报错值错误

1
2
teleplays = ['海上繁花','你微笑时很美','九千米爱情','回家的诱惑', '康熙王朝', '破产姐妹', '亮剑']
teleplays.remove('aaa')

如果存在多个相同的值时,只会删除第一个

1
2
3
aa = [10,20,30,10,10,50]
aa.remove(10)
print(aa)

2.1.3 pop方法

列表.pop() - 取出列表最后一个元素,可以用来

列表.pop(下标) - 取出列表指定下标对应的元素

1
2
3
4
5
6
7
8
teleplays = ['海上繁花','你微笑时很美','九千米爱情','回家的诱惑', '康熙王朝']
aa = teleplays.pop()
print(teleplays)
print(aa)

bb = teleplays.pop(3)
print(teleplays)
print(bb)

2.1.4 列表.clear() - 将列表清空

1
2
3
teleplays = ['海上繁花','你微笑时很美','九千米爱情','回家的诱惑']
teleplays.clear()
print(teleplays)

3.改 - 修改元素的值

语法: 列表[下标] = 值 - 将指定下标对应的元素修改成指定的值

1
2
3
4
teleplays = ['海上繁花','你微笑时很美','九千米爱情','回家的诱惑']
print(teleplays)
teleplays[3] = '庆余年'
print(teleplays)

练习1：将低于60分的成绩改成0

方法1

1
2
3
4
5
scores = [90, 45, 56, 89, 76, 56, 92, 45, 30, 59, 67, 70]
for index in range(len(scores)):
    if scores[index] < 60:
        scores[index] = 0
print(scores)
1
2
3
4
5
scores = [90, 45, 56, 89, 76, 56, 92, 45, 30, 59, 67, 70]
for item in scores:
    if item < 60:
        scores[scores.index(item)] = 0
print(scores)

方法2

1
2
3
4
5
scores = [90, 45, 56, 89, 76, 56, 92, 45, 30, 59, 67, 70]
for index,item in enumerate(scores):
    if item<60:
        scores[index] = 0
print(scores)

方法3

在保留元数据的情况,产生新列表进行修改

1
2
3
4
5
6
7
8
scores = [90, 45, 56, 89, 76, 56, 92, 45, 30, 59, 67, 70]
new_scores = []
for item in scores:
    if item < 60:
        new_scores.append(0)
        continue
    new_scores.append(item)
print(new_scores)

练习2：删除列表中低于60分的成绩

方法1

1
2
3
4
5
6
7
8
9
10
scores = [90, 45, 56, 89, 76, 56, 92, 45, 30, 59, 67, 70]
count = 0
for index in range(len(scores)):
    if scores[index] < 60:
        scores[index] = 0
        count+=1
while count:
    scores.remove(0)
    count-=1
print(scores)

方法2

1
2
3
4
5
scores = [90, 45, 56, 89, 76, 56, 92, 45, 30, 59, 67, 70]
for item in scores[::-1]:
    if item<60:
        scores.remove(item)
print(scores)

方法3

1
2
3
4
5
6
7
8
9
scores = [90, 45, 56, 89, 76, 56, 92, 45, 30, 59, 67, 70]
index = 0
while index<len(scores):
    if scores[index]<60:
        scores.pop(index)    #pop方法
        # del scores[index]  #del方法
    else:
        index+=1
print(scores)

4.列表的运算

4.1 数学运算:+,*

4.1.1 列表1+列表2 - 将列表1和列表2合并为一个新的列表

4.1.2 列表1 * N 将N个列表1合并为一个新列表

1
2
print([1,2,3]+[4,5,6])
print([1,2,3,4]*3)

4.2比较运算符:==,!=,>,<,>=,<=

4.2.1 ==,!= 必须要元素个数相等和对应元素相同才相等

1
2
print([1,2,3] == [1,2,3]) #True
print([1,2,3] == [1,3,2]) #False

4.2.2 列表1 > (>=,<,<=) 列表 不看元素个数

原理:比较的是第一对不相等的元素大小(两个列表下标相等为一对,下标从0开始)

1
print([1,20,3,40]>[10,1]) #False

4.3 in 或 not in

功能:判断列表中是否存在或不存在指定元素

1
2
3
print(10 in [10,20,30,])  #True
print([10,20] in [10,20,30]) #False
print([10,20] in [10,[10,20],20])  #True

实例

判断分数值是不是100或者0或者60

1
2
3
score = 60
if score==100 or score==0 or score ==60:
    print("特殊值")
1
2
3
score = 60
if score in [0,60,100]:
    print("特殊值")

4.4列表相关方法:count,index,reverse,sort,copy

4.4.1 count方法 列表.count(元素) - 统计指定的元素的个数

元素不存在返回0

1
2
nums = [10,20,30,4,10,20,10,20]
print(nums.count(10))

4.4.2 index方法 列表.index(元素) - 获取指定元素第一次在列表出现的下标

元素不存在会报错

1
2
nums = [10,20,30,4,10,20,10,20]
print(nums.index(20))

4.4.3 reverse方法 列表.reverse() - 将列表翻转

1
2
3
nums = [10,20,30,4,10,20,10,20]
nums.reverse()
print(nums)

4.4.4 sort方法 列表.sort() - 将列表从小到大排序

1
2
3
nums = [10,20,30,4,10,20,10,20]
nums.sort()
print(nums)

列表.sort(reverse = True) - 将列表从大到小排序

1
2
3
nums = [10,20,30,4,10,20,10,20]
nums.sort(reverse=True)
print(nums)

4.4.5 copy方法 列表.copy() - 复制列表产生一个相同的新列表

1
2
3
list1 = [1,2,3,4,5,6]
list2 = list1.copy()
print(list2)

作业题

1.已知一个数字列表，求列表中心元素。

1
2
3
4
5
list1 = [1,2,3,4,5,6]
if len(list1) % 2 ==0:
    print(list1[len(list1)//2-1],list1[len(list1)//2])
else:
    print(list1[len(list1)//2])

2.已知一个数字列表，求所有元素和。

1
2
3
4
5
list1 = [1,2,3,4,5,6]
sum1 = 0
for item in list1:
    sum1+=item
print(sum1)

3.已知一个数字列表，输出所有奇数下标元素。

1
2
3
4
list1 = [1,2,3,4,5,6]
for item in list1:
    if list1.index(item) % 2 !=0:
        print(item)

4.已知一个数字列表，输出所有元素中，值为奇数的元素。

1
2
3
4
list1 = [1,3,2,5,4,6]
for item in list1:
    if item % 2 !=0:
        print(item)

5.已知一个数字列表，将所有元素乘二。

1
2
3
4
list1 = [1,2,3,4,5,6]
for index in range(len(list1)):
    list1[index] *=2
print(list1)

6.有一个长度是10的列表，数组内有10个人名，要求去掉重复的

1
2
3
4
5
6
7
8
names = ['张三', '李四', '大黄', '大黄', '张三',
         '张三', '张三','王二','王五','李四']
new_names=[]
new_names.append(names[0])
for index in range(len(names)):
    if names[index] not in new_names:
        new_names.append(names[index])
print(new_names)

7.用一个列表来保存一个节目的所有分数，求平均分数(去掉一个最高分，去掉一个最低分，求最后得分)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
scores = [6,8,8,9,7,6,5,4,]
max = scores[0]
min = scores[0]
avg = 0
for item in scores:
    if item>max:
        max = item
    if item<min:
        min = item
scores.remove(max)
scores.remove(min)
for item in scores:
    avg += item
print("节目平均分数是：",avg/len(scores))

8.有两个列表A和B，使用列表C来获取两个列表中公共的元素

1
2
3
4
5
6
7
A = [1,2,3,4,5,6,7,8]
B = [6,7,8,9,10,11,12]
C = []
for item in A:
    if item in B:
        C.append(item)
print(C)

9.有一个数字列表，获取这个列表中的最大值.(注意: 不能使用max函数)

1
2
3
4
5
6
scores = [6,8,8,9,7,6,5,4,]
max = scores[0]
for item in scores:
    if item>max:
        max = item
print(max)

10.获取列表中出现次数最多的元素

1
2
3
4
5
6
7
8
9
10
11
12
13
nums = [1, 2, 3,1,4,2,1,3,7,3,3]
new_nums=[]
new_nums.append(nums[0])
for index in range(len(nums)):
    if nums[index] not in new_nums:
        new_nums.append(nums[index])
count1 = 0
item1 = 0
for item in new_nums:
    if nums.count(item) > count1:
        count1 = nums.count(item)
        item1 = item
print(item1)
python基础

循环练习和列表基础

1.列表(list)

1.1说明

1)列表是容器型数据类型(序列),符号[],各个元素用逗号隔开

2)容器的特征:一个容器可以保存多个数据

3)元素:容器中每个独立的数据就是一个元素

4)列表是可变的(元素个数,值和顺序都可以改变) - 增,删,改,支持下标操作

5)列表对元素没有要求(任何类型数据都可以作为列表的元素)

1.2空列表

1
2
3
list1 = []
list2 = [ ]
print(type(list1),type(list2),len(list1),len(list2))

1.3列表可以保存多个数据

1
2
list3 = [1,2,3,4,6,8]
print(list3,len(list3))

1.4查 - 获取元素

1)查分三种情况:获取单个元素,切片,遍历(一个一个取)

2)语法：列表[下标]

3)说明：列表 - 任何结果是列表的表达式:保存列表的变量,具体的列表值

4)下标: 又叫索引,是元素在有序序列中的位置信息,从左往右从0开始,从又往左从-1开始

5)功能: 获取列表指定下标对应的元素

1
2
3
list4 = ["安琪拉","韩信","鲁班","虞姬","孙悟空","李白"]
print(list4.index("韩信"))
print(list4[1])

1.5遍历 - 将列表中元素一个一个取出来

方式1 - 直接输出元素

1
2
3
4
list5 = ["安琪拉","韩信","鲁班","虞姬","孙悟空","李白"]
for i in list5:
    print(i)
print('-'*20+'华丽的分割线'+'-'*20)

方式2 - 由下标找到值

1
2
3
list6 = ["安琪拉","韩信","鲁班","虞姬","孙悟空","李白"]
for i in range(len(list6)):  # range(-1,-len(list6)-1,-1)
    print(list6[i])

方式3 - 同时获取元素和下标

说明: for 下标,元素 in enumerate(列表):

1
2
3
list7 = ["安琪拉","韩信","鲁班","虞姬","孙悟空","李白"]
for index,item in enumerate(list7):
    print(index,item)

练习1：统计不及格的人数

1
2
3
4
5
6
scores = [89,67,56,90,98,30,78,51,99]
count = 0
for i in scores:
    if i < 60:
        count+=1
print("不及格的人数是",count)

练习2：统计列表中的整数个数

1
2
3
4
5
6
list8 = [89,9.9,'abc',True,'abc','10',81,90,23]
count = 0
for i in list8:
    if type(i) == int:
        count+=1
print("列表中的整数个数是",count)

练习3：求 nums 中所有偶数的和

1
2
3
4
5
6
nums = [89,67,56,90,98,30,78,51,99]
sum1 = 0
for i in nums:
    if i % 2 == 0:
        sum1+=i
print("nums中所有偶数的和是",sum1)

1.6 增 - 添加元素

1.6.1添加单个元素

1)列表.append(元素) - 在列表的最后添加一个元素

1
2
3
4
movies = ['速度与激情','复仇者','极盗者','红海行动']
print(movies)
movies.append('战狼')
print(movies)

2)列表.insert(下标,元素) - 在指定下标对应元素前插入指定元素

1
2
3
4
movies = ['速度与激情','复仇者','极盗者','红海行动']
#在'极盗者'前面插入'战狼'
movies.insert(movies.index('极盗者'),'战狼')
print(movies)

3)列表1. extend(列表2) - 将列表2元素全部添加到列表1的后面

1
2
3
4
movies = ['速度与激情','复仇者','极盗者','红海行动']
print(movies)
movies.extend(['战狼','触不可及','V字仇杀队'])
print(movies)

练习1:将scores中所有及格的分数提取出来

1
2
3
4
5
6
scores = [89,67,56,90,98,30,78,51,99]
aa = []
for i in scores:
    if i > 60:
        aa.append(i)
print(aa)

循环练习题

1.判断101-200之间有多少个素数，并输出所有素数。

1
2
3
4
5
6
7
8
9
count = 0
for i in range(101,201):
    for j in range(2,i):
        if i % j == 0:
            break
    else:
        count+=1
        print(i,"是素数")
print("一共有",count,"个素数")

2.求整数1~100的累加值，但要求跳过所有个位为3的数。

1
2
3
4
5
sum1 = 0
for i in range(1,101):
    if i % 10 !=3:
        sum1 += i
print(sum1)

3.有⼀分数序列：2/1,3/2,5/3,8/5,13/8,21/13…求出这个数列的第20个分数

1
2
3
4
5
n1 = 1
n2 = 2
for i in range(19):
    n1,n2=n2,n1+n2
print(n2,"/",n1)

4.写程序计算 n 的阶乘 n! 的结果

1
2
3
4
5
6
7
n = int(input("请输入一个正整数："))
m = n
k = 1
while n:
    k*=n
    n=n-1
print(m,"的阶乘是",k)

5.求1+2!+3!+…+20!的和

1
2
3
4
5
6
7
8
sum1 = 0
for i in range(1,21):
    k = 1
    while i:
        k *= i
        i -= 1
    sum1 += k
print(sum1)

6.写程序求表达式 a + aa + aaa + aaaa+ … 的结果，其中a是1~9的数字，求和的项数用n来控制。（a和n可以用变量来表示）

例如：a为3， n为5的时候： 3 + 33 + 333 + 3333 + 33333

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import random
a = random.randint(1,9)
b = a
n = int(input("请输入一个正整数："))
sum1 = 0
c = []
while n:
    sum1 += a
    n = n-1
    c.append(a)
    c.append('+')
    a = a*10 +b
d = ''
for i in range(len(c)-1):
    d+=str(c[i])
print(d,"=",sum1)

7.控制台输出三角形

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
a.根据n的值的不同，输出相应的形状
n = 5时             n = 4
*****               ****
****                ***
***                 **
**                  *
*

b.根据n的值的不同，输出相应的形状(n为奇数)
n = 5               n = 7
  *                    *
 ***                  ***
*****                *****
                    *******

c. 根据n的值的不同，输出相应的形状
n = 4
   1
  121
 12321
1234321

n = 5
    1
   121
  12321
 1234321
123454321

a.根据n的值的不同，输出相应的形状

1
2
3
4
n = int(input("请输入一个正整数："))
while n:
    print("*"*n)
    n-=1

b.根据n的值的不同，输出相应的形状(n为奇数)

1
2
3
4
5
6
7
n = int(input("请输入一个正整数："))
i = int((n+1)/2)
j = 1
while i:
    print(" "*i,"*"*j)
    i -= 1
    j += 2

c. 根据n的值的不同，输出相应的形状

1
2
3
4
5
6
7
8
9
n = int(input('请输入整数n：'))
for x in range(n+1):  
    for i in range(n-x):  
        print(' ', sep='', end='')
    for j in range(1, x+1):
        print(j, sep='', end='')
    for k in range(x-1, 0, -1):
        print(k, sep='', end='')
    print()

8.小明单位发了100元的购物卡，小明到超市买三类洗化用品，洗发水（15元），香皂（2元），牙刷（5元）。要把100元正好花掉，可有哪些购买结合？

1
2
3
4
5
for i in range(7):   #i是洗发水
    for j in range(21):  #j是牙刷
        for k in range(51):  #k是香皂
            if i*15 + j*5 +k*2 == 100:
                print("可以购买洗发水，牙刷，香皂个数分别为：",i,j,k)

9.一张纸的厚度大约是0.08mm，对折多少次之后能达到珠穆朗玛峰的高度（8848.13米）？

1
2
3
4
5
6
7
8
9
count = 0
h = 0.08
k = 1
while True:
    if h>8848130:
        break
    h = h * 2**k
    count+=1
print(count)

10.古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？

1
2
3
4
5
6
7
8
9
n1 = 1
n2 = 1
n = int(input("请输入是第几个月："))
if n == 1 or n == 2:
    print(n,"个月的兔子数是：",1)
else :
    for i in range(n-3):
        n1,n2=n2,n1+n2
    print(n,"个月的兔子数是：",n1+n2)

11.将一个正整数分解质因数。例如:输入90,打印出90=2x3x3x5。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
n = int(input("请输入一个正整数："))
m = n
flag = False
for i in range(2,n):
    if n % i == 0:
        flag = True
        break
else:
    print(n,"=",1,"×",n)
if flag == True:
    k = 2
    aa = []
    while n:
        if n % k ==0:
            aa.append(k)
            aa.append('×')
            n = n // k
            if n == 1:
                break
        else:
            k +=1
    bb = ''
    for j in range(len(aa)-1):
        bb+=str(aa[j])
    print(m,"=",bb)

12.某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。求输入的四位整数加密后的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
n = input("请输入一个四位数整数:")
while n:
    if len(n) !=4:
        print("输入有误,请重新输入")
        n = input("请输入一个四位数整数:")
    else:
        n = int(n)
        ge = ((n % 10)+5) % 10
        shi = ((n //10% 10)+5) % 10
        bai = ((n //100% 10)+5) % 10
        qian = ((n //1000)+5) % 10
        k1 ,k2 =ge,shi
        ge,qian = qian,k1
        shi,bai = bai,k2
        print("加密后的值为:",qian*1000+bai*100+shi*10+ge)
        break

13.本金10000元存入银行，年利率是千分之三。每过1年，将本金和利息相加作为新的本金。计算5年后，获得的本金是多少。

1
2
3
4
a = 10000
for i in range(5):
    a = a * (1+0.003)
print(a)

14.输入一个整数，计算它各位上数字的和。（注意：输入的整数可以是任意位）

1
2
3
4
5
6
n = int(input("请输入一个整数："))
sum1 = 0
while n:
    sum1 += n % 10
    n //=10
print(sum1)

15.求两个数的最大公约数和最小公倍数。（提示：公约数一定小于等于两数中的小的那个数，且能同时被两个数整除；公倍数一定大于等于两数中的大数，且是大数的倍数又能被两数中的小数整除）

1
2
3
4
5
6
7
8
9
10
11
12
13
n1 = int(input("请输入一个整数n1:"))
n2 = int(input("请输入一个整数n2:"))
if n1 > n2:
    k = n1
else:
    k = n2
while True:
    if k % n1 == 0 and k % n2 ==0:
        print(n1,"和",n2,"的最小公倍数是",k)
        print(n1,"和",n2,"的最大公约数是",n1*n2//k)
        break
    else:
        k+=1
python基础

循环结构

循环 - 让代码重复执行

1. for循环

1.1语法：

for 变量 in 序列:

#### 循环体

1.2说明：

1)for in - 都是关键字，固定写法

2)变量 - 自定义一个变量名

3)序列 - 容器型数据类型对应的数据

4)常见的序列：字符串,元组,列表,字典,迭代器,生成器,集合

5)循环体：重复执行的代码段

6)执行过程：变量依次从序列中取值，取一次循环体执行一次，直到取完

1
2
for i in "I Love You":
print(i)

1.3 range 函数 - 产生指定的数字序列

1)range(N) 产生[0-N)的数字序列,步长默认为1

2)range(M,N) 产生[M,N)的数字序列,步长默认为1

3)range(M,N,step) 产生[M,N)的数字序列 step为指定步长的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
for i in range(10):
    print(i)
ptrint("---------------------")
a = 0
for i in range(0,100):
    a+=1
    print("hello")
print(a)
ptrint("---------------------")
for i in range(10,20,2):
    print(i)
ptrint("---------------------")
for i in range(20,2,-3):
    print(i)

练习1：打印100以内所有的偶数

1
2
for i in range(0,100,2):
    print(i)

练习2：打印100-200中所有个位数是3的数

1
2
3
for i in range(100,200):
    if i % 10 == 3:
        print(i)

练习3：打印所有的水仙花数

1
2
3
for i in range(100,1000):
    if (i//100)**3+(i//10%10)**3+(i%10)**3 == i:
        print("水仙花数：",i)

练习4：统计100以内的偶数个数

1
2
3
4
5
count = 0
for i in range(100):
    if i % 2 == 0:
        count+=1
print(count)

练习5：统计100以内能被3整除的偶数的个数

1
2
3
4
5
count = 0
for i in range(100):
    if i % 6 == 0:
        count+=1
print(count)

练习6：计算1+2+3+….+100的和

1
2
3
4
sum = 0
for i in range(101):
    sum += i
print(sum)

练习7：计算所有水仙花数的和

1
2
3
4
5
sum = 0
for i in range(100,1000):
    if (i//100)**3+(i//10%10)**3+(i%10)**3 == i:
        sum += i
print(sum)

2.while 循环

2.1语法：

while 条件语句:

循环体

2.2说明：

2.2.1while - 关键字,固定写法

2.2.2条件语句 - 任何有结果的表达式

2.2.3循环体 - 重复执行的代码段

2.3规则：

2.3.1先判断条件,true执行循环体,执行完再次判断,

2.3.2如果为true再次执行,以此类推,直到条件不成立,循环结束

练习:使用while打印十个hello

1
2
3
4
num = 0
while num<10:
    print("hello")
    num += 1

2.4while 和 for的选择

2.4.1for循环：循环次数确定的时候使用

2.4.2while循环：循环次数不确定的时候使用

练习：提示用户不断输入内容，直到输入的数据是0停止

1
2
3
b = input("请输入：")
while b !='0':
    b = input("请输入：")

3.循环关键字

3.1 continue 和 break

3.1.1 说明:只能出现在循环体中,for循环与while循环都可

3.1.2 continue - 结束一次循环/结束当次循环

如果遇到continue，当次循环结束，直接执行下一次循环

实例1

1
2
3
4
for i in range(4):
    print('======')
    continue
    print('++++++')

实例2

1
2
3
4
5
for i in range(10):
    if i == 5 or i == 8:
        continue
    print(i)

3.1.3 break - 结束整个循环

如果遇到break,整个循环结束

实例1

1
2
3
for i in range(10):
    print(i)
    break

实例2

1
2
3
4
for i in range(10):
    if i == 5:
        break
    print(i)

实例3

1
2
3
4
while True:
    value = input("请输入：")
    if value == '0':
        break

3.2 else关键字

说明:

for循环
for 变量 in 序列:
循环体
else:
代码段

while循环
while 条件语句:
循环体
else:

代码段

重点:else结构的存在不影响原来循环的执行

当循环正常结束时,继续执行else后面的代码段,否则不执行

实例1

1
2
3
4
for i in range(4):
    print(i,"====")
else:
    print("正常")

实例2

1
2
3
4
5
6
for i in range(4):
    print(i,"====")
    if i == 2:
        break
else:
    print("正常")

通过实例1和实例2的对比看else的作用,while相同

基础题

  1. 使用for和while循环输出 0~100内所有3的倍数。

    for循环

    1
    2
    for i in range(0,100,3):
        print(i)

    while循环

    1
    2
    3
    4
    5
    x = 0
    while x<100:
        if x % 3 ==0:
            print(x)
        x+=1

  2. 使用for和while循环输出100~200内个位数或者十位数能被3整除的数。

    for循环

    1
    2
    3
    for i in range(100,200):
        if (i%10) % 3 ==0 or (i//10%10) % 3 ==0:
            print(i)

    while循环

    1
    2
    3
    4
    5
    x = 100
    while x<200:
        if (x % 10) % 3 == 0 or (x // 10 % 10) % 3 == 0:
            print(x)
        x+=1

  3. 统计100~200中十位数是5的数的个数

    1
    2
    3
    4
    5
    count = 0
    for i in range(100,200):
        if i//10%10 == 5:
            count+=1
    print(count)

  4. 打印50~150中所有能被3整除但是不能被5整除的数

    1
    2
    3
    for i in range(50,150):
        if i % 3 ==0 and i % 5 !=0:
            print(i)

  5. 计算50~150中所有能被3整除但是不能被5整除的数的和

    1
    2
    3
    4
    5
    sum = 0
    for i in range(50,150):
        if i % 3 ==0 and i % 5 !=0:
            sum+=i
    print(sum)

进阶题

  1. 使用循环计算1*2*3*4*...*10的结果。

    1
    2
    3
    4
    k = 1
    for i in range(1,11):
        k*=i
    print(k)

  2. 统计100以内个位数是2并且能够被3整除的数的个数。

    1
    2
    3
    4
    5
    count = 0
    for i in range(100):
        if i % 10 == 2 and i % 3 == 0:
            count+=1
    print(count)

  3. 输入任意一个正整数，求他是几位数？

    注意: 这儿不能使用字符串，只能用循环

    1
    2
    3
    4
    5
    6
    b = int(input("请输入一个正整数："))
    count = 0
    while b>0:
        b //=10
        count+=1
    print("它是一个",count,"位数")

  4. 打印出所有的水仙花数,所谓水仙花数是指一个三位数，其各位数字⽴方和等于该数本身。例如:153是⼀个⽔仙花数,因为 1³ + 5³ + 3³ 等于 153。

    1
    2
    3
    for i in range(100,1000):
        if (i//100)**3+(i//10%10)**3+(i%10)**3 == i:
            print("水仙花数：",i)

挑战题

  1. 判断指定的数是否是素数（素数就是质数，即除了1和它本身以外不能被其他的数整除的数）

    1
    2
    3
    4
    5
    6
    7
    x = int(input("请输入一个数："))
    for i in range(2,x):
        if x % i == 0:
            print("这个数不是素数")
            break
    else:
        print("这个数是素数")

  2. 求斐波那契数列列中第n个数的值:1，1，2，3，5，8，13，21，34…. （这儿的n可以是任意正整数，可以通过输入来确定）

    1
    2
    3
    4
    5
    6
    7
    8
    9
    n = int(input('请输入一个正整数：'))
    n1 = 0
    n2 = 1
    sum  = 1
    for i in range(2, n+1):
        sum = n1 + n2
        n1 = n2
        n2 = sum
    print('第',n,'个数是',sum)

  3. 输出9*9口诀。 程序分析：分行与列考虑，共9行9列，i控制行，j控制列。

    1
    2
    3
    4
    for i in range(1,10):
        for j in range(1,i+1):
            print(i,"*",j,"=",i*j,end='   ')
        print("")

  4. 这是经典的”百马百担”问题，有一百匹马，驮一百担货，大马驮3担，中马驮2担，两只小马驮1担，问有大，中，小马各几匹？（可以直接使用穷举法）

1
2
3
4
5
for i in range(100):
    for j in range(100-i):
        for k in range(100-i-j):
            if 3*i+2*j+k == 100:
                print("有大，中，小马各",i,j,k,"匹")
python基础

运算符和分支结构

一.运算符和分支结构

1.数学运算符

1.1+(加),-(减),*(乘),/(除),%(取余/求模),//(整除),**(幂运算)

1.1.1+,-,*,/与数学中的+,-,×,÷,相同

1
2
3
4
print(5+2)  #7
print(6-6)  #0
print(26*2)  #52
print(2/2)  #1.0

1.1.2% 求余数,取模:x%y求x除以y的余数

1
2
print(5%2)  #1
print(8%2)  #0
应用1：判断一个数能否被另一个数整除(判断余数是否为0)
1
2
3
4
5
6
7
x = 5
y = 3
a = x%y
if a == 0:
    print("x可以被y整除")
else:
    print("x不可以被y整除")
应用2：取低位数/取个位(对10或者10的幂次方取余)
1
2
num = 2335
print(num%10) #取个位5

1.1.3// - 整除 x/y的商只取整数

1
2
3
print(5//2)  #2
print(1.8//2)  #0.0
print(-5//2)  #-3
应用：正整数去低位/去个位
1
2
num = 23456
print(num // 10) #2345
练习：获取指定正整数的十位数
1
2
3
num = 3945
print(num // 10 % 10) #去个位在取个位  4
print(num % 100 // 10) #取个位和十位在去个位  4
练习2：获取指定正整数的百位数
1
2
3
num = 3945
print(num // 100 % 10) #去个位和十位在取个位  9
print(num % 1000 // 100) #取个位和十位和百位在去个位和十位  9

1.1.4** - 幂运算 x**y 求x的y次方

1
2
3
4
print(2**3)  #8
print(16**0.5)  #4.0
print(2.2**2)   #4.840000000000001
print(2.0**2)   #4.0

2.比较运算符：>(大于),>=(大于等于),<(小于),<=(小于等于),==(等于),!=(不等于)

2.1重要结论：所有的比较运算的运算结果都是布尔

1
2
3
4
5
6
7
8
9
10
print(10 > 10)  #False
print(10 >= 10)  #True
print(10 < 10)  #False
print(10 <= 10)  #True
print(10 == 10)  #True
print(10 != 10)  #False
a = (10==10)
print(a == (10==10))
if a==1:
    print("003")  #true=1/false=0

2.2注意：python中的比较运算符可以像数据一样通过连写来表示范围

1
2
age = 20
print(18 <= age <= 28)  #true

3.逻辑运算符 - and(逻辑与运算),or(逻辑或运算),not(逻辑非运算)

3.1 and - 逻辑与运算 ,并且,连接需要同时满足的多个条件

运算规则：条件1 and 条件2 全真为真，有假为假

1
2
3
4
print(True and True)
print(True and False)
print(False and True)
print(False and False)
练习：写出一个数能同时被3和7整除的条件
1
2
3
4
5
6
aa = 63
if aa % 3 == 0 and aa % 7 == 0:   #aa % 21 == 0
    print("这个数能被3和7整除")
else:
    print("这个数不能被3和7整除")
print(aa % 3 == 0 and aa % 7 == 0,aa%21==0)

3.2 or - 逻辑或运算 ,或者,连接需要满足的其中一个条件

运算规则：条件1 or 条件2 全假为假，有真为真

1
2
3
4
print(True or True)
print(True or False)
print(False or True)
print(False or False)
练习1：判断是否能拿奖学金，条件(绩点高于4,或者操评分不低于95)
1
2
3
4
5
6
gpa = 3.8
score = 98
if gpa > 4 or score >=95:   #满足其中一个条件即可
    print("可以获得奖学金")
else:
    print("不能拿奖学金")
练习2：判断指定年是否为闰年(普通闰年：公历年份是4的倍数的，且不是100的倍数，为普通闰年。世纪闰年：必须是400的倍数才是世纪闰年)
1
2
3
4
5
6
7
year = 2020
if year % 4 ==0 and year % 100 !=0:
    print("该年为普通闰年")
elif year % 400 ==0:
    print("该年为世纪闰年")
else:
    print("该年为平年")

3.3 not - 逻辑非运算 对指定条件进行否定(取反)

运算规则： not 条件

1
2
3
print(not True)   #False
num = 18
print(not num == 18,num !=18)  #False False
练习：写出一个不能同时被3和7整除的条件(能被3整除不能被7整除，能被7整除不能被3整除，既不能被3整除也不能被7整除)
1
2
num = 22
print(not num % 21 == 0)
一般用于正向条件情况很复杂，反向条件很简单的时候

3.4 短路操作：

规则：条件1 and 条件2 如果条件1为False,结果为条件1，条件2不执行

条件2 or 条件2 如果条件1为True,结果为条件1，条件2不执行

1
2
3
4
False and print("aaa")
True or print("bbb")
1 and print("aaa")
0 or print("bbb")

3.5 逻辑运算符的扩展 - 运算对象不是布尔值

1
2
3
4
print(1 and "49")   #and情况下如果数据1的布尔值是True,结果就是数据2，否则为数据1 #49
print(1 and 49)  #49
print(0 and 49)  #0
print(6 or 7)    #or情况下如果数据1的布尔值是True,结果就是数据1，否则为数据2 #6

着重点：数据的布尔值 - 数据转成布尔的结果 python中所有类型数据都有布尔值

所有的零值和控制对应的布尔值都是False，其它数据的布尔值都是True

常见的零值和空值：0,0.0,’’,[],(),{},none

1
print(bool(2)==True,bool(0)==True,True==bool(2),True==bool([]))

4.赋值运算符：=,+=,-=,*=,/=,%=,//=,**=

重要结论：所有赋值运算符都是为了给变量赋值 左边必须为变量

4.1 = - 定义变量,给变量重新赋值

规则：把右边的值赋值给左边的变量

1
2
a = 1
print(a) #1

4.2 +=,-=,*=,/=,%=,//=,**=

规则：把左边的变量的值加上,减去,乘上,除去,取模,整除,平方右边的值之后的值在重新赋值给变量

1
2
3
4
5
6
7
8
9
10
11
b = 1
b += 8
print(b) #9
b -= 3
print(b) #6
b **= 2
print(b) #36
b //= 4
print(b) #9
b %= 2
print(b) #1

4.3运算符的优先级

数学运算符>比较运算符>逻辑运算符>赋值运算符

数学运算符：** > *,/,%,// > +,- 有括号先算括号

5.流程控制

5.1顺序结构 - 从上往下依次执行，每条语句执行一次

1
2
print(1)
print(2)

5.2分支结构 - 代码的执行看条件是否成立 (if语句)

5.2.1单分支结构 - 如果条件成立就执行某个操作，否则就不执行

语法：

if 条件语句: #if - 关键字，固定 条件语句 - 任何有结果的表达式
代码段
#判断条件是否为True,为True执行代码段，否则不执行
#如果条件语句不是布尔，就转换为布尔来看

1
2
3
4
a = 1
if a == 1:
    print(True)
    print("aaa")
练习1：如果指定的数是偶数就打印偶数
1
2
3
4
5
b = 22
if b % 2 ==0:
    print("偶数")
if not b % 2:
    print("偶数")
练习2：如果指定的数是奇数就打印奇数
1
2
3
4
5
b = 23
if b % 2 !=0:
    print("奇数")
if b % 2:
    print("奇数")
练习3：判断指定(100,1000)数据是否为水仙花数
水仙花数：个位的3次方+十位的三次方+百位的三次方=它本身
1
2
3
a = 153
if (a % 10) ** 3 + (a // 10 % 10) ** 3 + (a // 100) ** 3 == a:
    print("是水仙花数")

5.2.2双分支结构 - 如果条件成立就执行某个操作，否则就执行另一个操作

1
2
3
4
5
a = 1
if a == 1:
    print(True)
else:
    print(False)

5.2.3多分支结构 - 如果条件成立就执行某个操作，否则判断另一个条件是否成立

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
age = 50
if age<14:
    print(age)
    print("儿童")
elif age<18:
    print(age)
    print("青少年")
elif age<26:
    print(age)
    print("青年")
elif age<50:
    print(age)
    print("中年")
else:
    print(age)
    print("老年")
练习1：判断分数等级
1
2
3
4
5
6
7
8
9
score = 89
if score > 90:
    print("A")
elif score >= 80:
    print("B")
elif score >= 60:
    print("C")
else:
    print("D")

二.作业

选择题

  1. print(100 - 25 * 3 % 4) 应该输出什么? （B）

    A. 1

    B. 97

    C. 25

    D. 0

  2. 下列哪种说法是错误的（A）。

    A. 除字典类型外，所有标准对象均可以⽤于布尔测试

    B. 空字符串的布尔值是False

    C. 空列表对象的布尔值是False

    D. 值为0的任何数字对象的布尔值是False

  3. 下列表达式的值为True的是（B）。

    A. 3>2>2

    B. 1 and 2 != 1

    C. not(11 and 0 != 2)

    D. 10 < 20 and 10 < 5

  4. Python不⽀持的数据类型有（A）。

    A. char

    B. int

    C. float

    D. list

  5. （多选）n = 6784，以下能够获取到7 的⽅法有（C,D）。

    A. n / 1000 % 100

    B. n % 1000 / 100

    C. n // 100 % 10

    D. n // 10 % 100 // 10

  6. 运⾏以下程序，当从键盘上输⼊12,运⾏结果是（A）。

    1
    2
    x = (input())
    print(type(x))

    A. <class 'str'>

    B. <class 'int'>

    C. 出错

    D. <class 'dict'>

  7. 下列表达式的运算结果是( D) 。 

    1
    2
    3
    a = 100
    b = False
    print(a * b > -1)

    A. False

    B. 1

    C. 0

    D. True

填空题

  1. 查看变量中数据的类型的函数名是（type）。
  2. 已知 x = 3 == 3 ,执⾏结束后，变量x的值为（True）。
  3. 已知 x = 3 ，那么执⾏语句 x += 6 之后，x的值为（9）。
  4. 表达式 3 ** 2 的值为（9）,表达式 3 * 2 的值为（6），表达式 4 ** 0.5 的值为（2.0）。

编程题

  1. 写出判断⼀个数是否能同时被2和5整除的条件语句, 并且打印对应的结果。

    1
    2
    3
    4
    5
    num = 20
    if num % 10 == 0:
        print(num,"能同时被2和5整除")
    else:
        print(num,"不能同时被2和5整除")

  2. 写出判断⼀个数是否能够被2或者5整除，但是不能同时被2或者5整除的条件语句， 并且打印对应

    的结果。

    1
    2
    3
    4
    5
    num = 20
    if num % 10 !=0 and (num % 2==0 or num % 5==0):
        print(num,"能够被2或者5整除，但是不能同时被2或者5整除")
    else:
        print(num,"不满足能够被2或者5整除，但是不能同时被2或者5整除")

  3. 假设今天的上课时间为15678秒，编程计算今天上课时间是多少⼩时，多少分钟，多少秒；以‘XX

    时XX分XX秒’的⽅式表示出来。

    例如：100秒表示成 0时1分40秒

    1
    2
    3
    4
    5
    time = 15678
    hour = time // 3600
    min = (time-hour*3600)//60
    sec = time-hour*3600-min*60
    print("今天上课时间为：",hour,"小时",min,"分钟",sec,"秒")

  4. 定义两个变量保存⼀个⼈的身⾼和体重，编程实现判断这个⼈的身材是否正常!

    公式: 体重(kg) / (身⾼(m)的平⽅值 ) 在18.5 ~ 24.9之间属于正常。

    输出格式： 是否正常：True/False

    1
    2
    3
    4
    5
    6
    kg = 70
    m = 1.75
    if 18.5<= (kg / m**2) <=24.9:
        print(True)
    else:
        print(False)

  5. 根据输入的成绩的范围打印及格 或者不及格

    1
    2
    3
    4
    5
    6
    7
    score = 88
    if score>=60:
        print(score)
        print("及格")
    else:
        print(score)
        print("不及格")

  6. 根据输入的年纪范围打印成年或者未成年，如果年龄不在正常范围内(0~150)打印这不是人!

    1
    2
    3
    4
    5
    6
    7
    age = 18
    if 0 <= age < 18:
        print("未成年")
    elif 18 <= age <=150:
        print("成年")
    else:
        print("这不是人!")

  7. 输入两个整数a和b，若a-b的结果为奇数，则输出该结果，否则输出提示信息a-b的结果不是奇数。

    1
    2
    3
    4
    5
    6
    a = 22
    b = 9
    if (a-b) % 2 !=0:
        print(a-b)
    else:
        print("a-b的结果不是奇数")
python基础

基础语法和变量

1.第一个python程序

1
2
a = "Hello World!" #a为变量，= 赋值，"Hello World!"为字符串str
print(a) #print 输出打印内容

2.软件的快捷操作方式

ctr + / - 添加/取消注释

ctr + s - 保存

ctr + c - 复制

ctr + v - 粘贴

ctr + x - 剪切

ctr + z - 撤销

ctr + y / ctr + shift + z - 反撤销

按住alt键可以出现多个光标

3.注释

对代码提供解释说明，方便理解，不被运行

单行注释 #

多行注释’’’ ‘’’/“”” “””

1
2
3
4
5
# a = 1
'''
b = 1 
c = 1
'''

一条有效代码就是一条语句

一般情况下一条语句占一行 一行中多条语句要使用分号隔开

通过缩进产生代码块 一般情况下四个空格为一个缩进

4.标识符和关键字

字母数字下划线组成不能以数字开头

变量名等不使用关键字命名

python 3以后可以使用中文作为标识符

关键字，本身的存在有特殊意义

1
2
3
4
5
a = 100
a1 = 100
a_=100
__ =100
1a = 30 #无效的标识符

5.常用数据和数据类型

1.数字数据 - 表示数值大小的数据
int(整形),float(浮点型),complex(复数)
2.文本数据 - 文字提供数据的数据,公司名称，姓名
程序中的文本数据需要加引号
文本对应的类型：str(字符串)
3.布尔数据 - 程序中用true表示真用false表示假 true/false
布尔对应的数据类型：Boolean(布尔)

4.其它数据类型：list列表，dict 字典，tuple元组，set集合，迭代器，生成器，function函数，自定义类型…

6.获取数据类型 type

格式为：type(数据)

1
2
a = 10
print(type(a))

7.类型转换

格式为：类型名(数据)

1
2
3
a = int(float(10.1))
print(a)
print(int('123'),float('123.1'))

8.输出函数 - print 输出 打印

1
2
a = 100
print(100,a,a+1,a//10,type(a))

9.定制结尾符号

格式为：end=’;’

1
2
3
4
5
6
7
8
9
10
11
print(100)
print(200)
'''
100
200
'''
print(100,end=',')
print(200,end='\n')
'''
100,200
'''

10.定制数据分隔符

格式为：sep = ‘ ‘

1
2
3
4
5
6
print('abc',200,sep=',')
print('abc',200,sep=',',end='')
print('abc',200,sep='+',end='')
print('abc',100,22,sep='-')
print(100,200,300,sep='+',end='=')
print(600)

11.输入函数 - input

1
2
3
4
5
6
7
input(输入提示信息)
name = input('请输入姓名：')
print(name)
#input输入的数据都是字符串str
age = input('请输入年龄:')
print(age,type(age))
print(int(age)+100)

12.什么是变量

变量就是保存数据的容器

1
2
message = 'aaa'
print(message)

13.定义变量(将数据保存到变量中)

语法：变量名=值

说明：变量要求是标识符

规范：见名知义(看到变量名就知道保存的东西)

不使用系统的函数名和模块名

= 赋值

值 - 有结果的表达式(具体的数据，运算表达式，函数调用表达式)

1
message = 'aaa'

14.使用变量

使用变量保存的数据

1
2
3
num = 18
print(num)
print(num+10)

15.重新赋值

再次给同一变量赋值

1
2
3
4
num = 18
print(num)
num = 20
print(num)

16.同时定义多个变量

同时定义多个变量并赋值

1
2
3
4
5
6
7
8
a=b=c=100 #相同值
x,y,z=100,'aaa',200   #不同值
print(a,b,c,x,y,z,sep=',')
a = 9999**9999
b = []
for i in str(a):
	b.append(i)
	print(b,len(b))

python申请数据的内存是按照数据的大小来申请的

定义变量时系统会自动在内存中申请空间，按照数据的大小来申请数据的内存空间大小

重新给变量赋值时，会申请新的内存空间，重新赋值，数据地址会发生改变

17. id 函数：id(变量) - 获取变量保存的数据的地址

1
2
3
4
a = 100
print(id(a))
a = 200
print(id(a))