python基础

迭代器与生成器

1.迭代器

1.1迭代器说明

1.1.1迭代器也是容器型数据类型,可以遍历,可以转化成列表和元组

1.1.2打印迭代器的时候无法打印里面的元素,迭代器不支持len操作

1.1.3如果需要迭代器中的元素,需要从迭代器中取出,取出之后迭代器中就没有了,且不能添加回去

1.2创建迭代器

1
2
方式1：通过iter将其他序列转换成迭代器
方式2：创建生成器对象(生成器是一种特殊的迭代器)

1.3获取迭代器的元素

1.3.1获取单个元素：next(迭代器)

1
2
3
4
iter1 = iter('abc')
print(next(iter1)) #a
print(next(iter1)) #b
print(next(iter1)) #c

1.3.2获取多个元素：通过循环遍历得到

2.生成器(generator)

2.1生成器是具备能够产生多个数据能力的一种容器。

2.2生成器在获取数据的时候和迭代器一样

2.3创建生成器 - 调用一个带有yield关键字的函数就可以得到一个生成器对象

2.4如果一个函数中存在yield,函数调用过程中不会执行函数体,也没有返回值,而是一个生成器对象

1
2
3
4
5
6
7
def func1():
    print('=====')
    yield
    print('+++++')
## 任意一个函数加上yield之后都是一个生成器对象
result = func1()
print('result:',result)

2.5 控制生成器产生数据的能力

执行生成器对应的函数会遇到几次yield,这个生成器就能产生多少个数据

每次遇到yield的时候,yield后面值就是对应产生的数据

1
2
3
4
5
6
7
def func2():
    yield 100
    for i in range(4):
        yield i
gen2 = func2()
for j in gen2:
    print(f'产生的数据：{j}')

练习1：创建一个生成器函数,可以产生前N个偶数,偶数从0开始

1
2
3
4
5
6
7
8
9
10
def func3(n):
    k = 0
    for i in range(n):
        yield k
        k += 2

gen3 = func3(5)

for x in gen3:
    print(x)

2.6生成器产生数据的原理

2.6.1通过生成器对象获取数据的时候,才会执行对应的函数,每次遇到yield的时候返回yield后面的数据

并记录该位置,然后从这里停止,下一次获取数据的时候从上一次结束的位置开始到下一个yield

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def func4():
    print('--------1---------')
    yield 100
    print('--------2---------')
    yield 200
    print('--------3---------')
    yield 300
    print('--------end---------')

gen4 = func4()
print(gen4)
print("取元素：", next(gen4))
print("==================")
print("取元素：", next(gen4))
print("+++++++++++++++++")
print("取元素：", next(gen4))

## print("取元素：",next(gen4))  ## 报错,此时元素已经取完了

3.模块

3.1 python中一个Py文件就是一个模块

3.2如何在一个模块中使用另一个模块的内容

1
2
3
4
5
6
7
1.首先被使用的模块的模块名必须是标识符并且不是关键字
2.一个模块可以使用另一个模块中的所有全局变量,使用之前要先导入
3.导入模块 import 模块名 - 导入指定模块 导入后通过'模块名.'的方式使用该模块中所有的全局变量
4.from 模块名 import 全局变量1,全局变量2... - 导入指定模块,可以直接使用指定全局变量
5.form 模块名 import * 导入指定模块,可以使用模块中的所有全局变量
6.import 模块名 as 新模块名 将原来的模块名改名作为一个新对象
7.from 模块名 import 全局变量名 as 新全局变量名

3.3导入模块的原理

3.3.1当通过import或者from-import导入一个模块时,系统会自动将这个模块中的代码执行一遍

1
2
import test_2
print(test_2.a)

4.包的使用 - 包就是包含__init__.py 文件的文件夹

4.1包的导入

1
2
3
4
5
6
7
## 直接导入包
import 包名 
## 通过包导入模块
import 包名.模块名 - 可以通过'包.模块.' 去使用指定模块中的所有全局变量
import 包名.模块名 as 新名称
from 包 import 模块名/* (as新名称)
from 包.模块 import 变量名1，变量名2 (as新名称)

4.2包的导入原理

1
2
3
通过包导入包中的模块的时候,
程序会先执行包中的__init__.py文件中的所有代码
然后在执行导入的模块的所有代码

4.3直接使用包中的快捷键

1
2
3
4
from files import read_excel
read_excel()

files.excel.read_excel()
python基础

匿名函数

1.匿名函数

1.1语法

1
2
3
4
5
函数名 = lambda 参数列表:返回值

相当于：
def 函数名(参数列表):
    return 返回值

实例1

1
2
sum1 = lambda x,y:x+y
print(sum1(1,2))

注意:不支持参数后面加冒号给出类型说明

练习1 - 获取指定数的个位数

1
2
get_gewei = lambda x: x % 10
print(get_gewei(232))

2.变量作用域 - 变量能够使用的范围(全局变量,局部变量)

2.1全局变量 - 没有定义在函数里面或者类里面的变量就是全局变量

2.1.1全局变量的作用域是从定义开始到程序结束

1
2
3
4
5
6
7
8
9
# a、b、c都是全局变量
a = 100

for b in range(10):
    print(b)
    c = 20
    print(f'循环里面使用a:{a}')

print(f'循环外面使用b和c:{b},{c}')

2.2 局部变量 - 定义在函数里面的变量就是局部变量(形参也是局部变量)

2.2.1局部变量的作用域是从定义开始到函数结束

1
2
3
4
5
6
7
8
9
def func2(x):
    y = 100
    for z in range(10):
        pass
    print(x,y,z)
    print("函数结束")

func2(10)
## print(x,y,z) 函数报错x,y,z没有被定义

补充:函数调用过程(内存的变化)

每次在调用函数时,系统的栈中会临时开辟一个内存空间供函数保存数据使用,函数调用结束就会释放这个内存空间

3. global 和 nonlocal

3.1 在函数中修改全局变量的值或者定义全局变量,需要在变量前面用global

3.2 nonlocal - 用于在局部的局部修改一个局部变量的值

1
2
3
4
5
6
7
8
9
10
11
m = 100
def func1():
    global m
    print(m)
    m = 200
    global n
    n = 20
    print(n)

func1()
print(m)

4. python中定义函数就是定义一个function类型的变量,函数名就是变量名

1
2
3
4
5
6
7
8
9
10
func1 = lambda x: x*2
print(type(func1))
## <class 'function'>

def func2():
    print("函数")
print(type(func2))
## <class 'function'>
c = func2
c()

func10 是返回值高阶函数-因为func10的返回值是函数

1
2
3
4
5
6
7
def func1O():
    def func11():
        print('hello')
        return 100
    return func11

print(func1O()())

5.实参高阶函数

5.1参数是函数的函数就是实参高阶函数

5.2常用的实参高阶函数

1
max,min,sorted,sort,map,reduce

5.2.1 - max,min,sorted,sort

1
2
max(序列)/max(序列,key=函数)
函数要求：有且只有一个参数,参数指向的是前面序列中的每个元素,有一个返回值(返回值就是比较对象)

max实例

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
29
nums = [89, 32, 52, 65, 21, 90]
print(max(nums, key=lambda x: x % 10))


nums = [89, '32', 52, '65', 21, 90]
print(max(nums, key=lambda x: int(x)))

'''c.获取年龄最大的学生信息；获取成绩最低的学生信息'''
students = [
    {'name': '小明', 'age': 18, 'score': 90},
    {'name': '老王', 'age': 28, 'score': 67},
    {'name': '张三', 'age': 22, 'score': 83},
    {'name': '李四', 'age': 25, 'score': 57}
]
print("获取年龄最大的学生信息", max(students, key=lambda x: x['age']), sep=':')

print("获取成绩最低的学生信息", min(students, key=lambda x: x['score']), sep=':')

'''d.获取nums各个位数的和的最大的元素'''

nums = [123, 97, 56, 109, 82]

def sum_gewei(x):
    sum1 = 0
    while x:
        sum1 += x % 10
        x //= 10
    return sum1
print(max(nums, key=sum_gewei))

5.2.2 map - map(函数,序列) 将序列中所有元素按照指定规则进行变换产生一个新的序列

函数要求：有一个参数(指向序列中的元素)

需要一个返回值(新序列中的元素,描述清楚新序列元素和原序列元素的关系)

1
2
3
4
5
6
7
8
9
10
11
nums = [23,45,78,91,56]
print(list(map(lambda item:str(item),nums)))


nums1=[1,2,3,4,5]
nums2=[6,7,8,9,1]
'''
[16，27， 38，49，51]
'''
result = map(lambda i1,i2: i1 * 10 + i2, nums1, nums2)
print(list(result))

5.2.2 map - map(函数,序列1,序列2)

1
2
3
4
5
map(函数，序列1，序列2)
函数要求:a.有两个参数，第一个参数指向序列1中的元素，第二个参数指向序列2中的元素
       b.需要一个返回值(新序列中的元素，描述清楚新序列元素和原序列元素的关系)

函数后面可以有N个序列，要求这N个序列中元素个数必须一致；有多少个序列
1
2
3
4
5
6
7
8
9
10
练习：
['小明', '张三', '李四', '老王']
[18, 30, 26, 35]

->
[
    {'name': '小明', 'age': 18},
    {'name': '张三', 'age': 30},
    ...
]
1
2
3
4
list1 = ['小明', '张三', '李四', '老王']
list2 = [18, 30, 26, 35]
result = map(lambda i1,i2:{'name':i1,'age':i2},list1,list2)
print(list(result))

5.2.3 reduce - reduce(函数,序列,初始值)

有且只有两个参数(第一个参数:第一次指向初始值,第二次开始指向上一次的运算结果)

(第二个参数:指向序列中的每个元素)

返回值:描述合并规则(用初始值和元素来描述)

实例1

1
2
3
4
5
6
7
nums = [1,2,3,4,5]
result = reduce(lambda x,y:x+y, nums, 0)
print(result)
result1 = reduce(lambda x,y:x*y, nums, 1)
print(result1)
result2 = reduce(lambda x,y:x+str(y),nums,'')
print(result2)

实例2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
students = [
    {'name': '小明', 'age': 18, 'score': 90},
    {'name': '老王', 'age': 28, 'score': 67},
    {'name': '张三', 'age': 22, 'score': 83},
    {'name': '李四', 'age': 25, 'score': 57}
]

## 将列表中的元素合并成'小明老王张三李四'

result = reduce(lambda x,y:x + y['name'],students,'')
print(result)

## 将列表中的元素合并成 ['小明','老王','张三','李四']

# result1 = reduce(lambda x,y:x+y['name'],students,'')
# list1 = []
# for item in range(0,len(result1),2):
#     list1.append(result1[item:item+2])
# print(list1)

result1 = reduce(lambda x,y:x+[y['name']],students,[])
print(result1)

作业

1. 已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标)

1
2
3
points = [
  (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
]

以下问题使用实参高阶函数来解决

1）获取列表中y坐标最大的点

1
2
result1 = max(points, key=lambda x:x[1])
print(result1)

2）获取列表中x坐标最小的点

1
2
result2 = min(points, key=lambda x:x[0])
print(result2)

3）获取列表中距离原点最远的点

1
2
result3 = max(points, key=lambda x:(x[0]**2 + x[1]**2)**0.5)
print(result3)

4）将点按照点到x轴的距离大小从大到小排序

1
2
result4 = sorted(points, key=lambda x:(x[1]**2),reverse=True)
print(result4)

2. 求列表 nums 中绝对值最大的元素

1
2
3
nums = [2,3,8,-9,5]
result2 = max(nums,key= lambda item : (item**2))
print(result2)

3. 已经两个列表A和B，用map函数创建一个字典，A中的元素是key，B中的元素是value

1
2
3
A = ['name', 'age', 'sex']
B = ['张三', 18, '女']
新字典: {'name': '张三', 'age': 18, 'sex': '女'}
1
2
3
4
A = ['name', 'age', 'sex']
B = ['张三', 18, '女']
result3 = map(lambda x,y: (x,y), A, B)
print(dict(result3))

4. 已经三个列表分别表示5个学生的姓名、学科和班号，使用map将这个三个列表拼成一个表示每个学生班级信息的的字典

1
2
3
4
names = ['小明', '小花', '小红', '老王']
nums = ['1906', '1807', '2001', '2004']
subjects = ['python', 'h5', 'java', 'python']
结果：{'小明': 'python1906', '小花': 'h51807', '小红': 'java2001', '老王': 'python2004'}
1
2
3
4
5
6
names = ['小明', '小花', '小红', '老王']
nums = ['1906', '1807', '2001', '2004']
subjects = ['python', 'h5', 'java', 'python']

result4 = map(lambda x,y,z: (x,z+y), names, nums,subjects)
print(dict(result4))

5. 已经一个列表message, 使用reduce计算列表中所有数字的和（用采用列表推导式和不采用列表推导式两种方法做）

1
2
message = ['你好', 20, '30', 5, 6.89, 'hello']
结果：31.89

不使用列表推导式

1
2
result5 = reduce(lambda item1,item2:item1+(item2 if type(item2) in [int,float] else 0) ,message,0)
print(result5)

使用列表推导式

1
2
result6 = reduce(lambda item1,item2:item1+item2,[x for x in message if type(x) in [int,float]],0)
print(result6)

6. 已知一个字典列表中保存的是每个学生各科的成绩，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
studens = [
  {'name': 'stu1', 'math': 97, 'English': 67, 'Chinese': 80},
  {'name': 'stu2', 'math': 56, 'English': 84, 'Chinese': 74},
  {'name': 'stu3', 'math': 92, 'English': 83, 'Chinese': 78},
  {'name': 'stu4', 'math': 62, 'English': 90, 'Chinese': 88}
]

# 计算平均分
studens = [
  {'name': 'stu1', 'math': 97, 'English': 67, 'Chinese': 80, 'avg':81},
  {'name': 'stu2', 'math': 56, 'English': 84, 'Chinese': 74, 'avg':71},
  {'name': 'stu3', 'math': 92, 'English': 83, 'Chinese': 78, 'avg':87},
  {'name': 'stu4', 'math': 62, 'English': 90, 'Chinese': 88, 'avg':80}
]

# 按照平均分从高到低排序
...

1）计算并添加每个学生的平均分

1
2
3
4
5
from functools import reduce
for student in studens:
    result = (reduce(lambda x,y:x+y,list(student.values())[1:],0))//3
    student['avg'] = result
print(studens)

2）按照平均分从高到低排序

1
2
result1 = sorted(studens,key= lambda x:x['avg'],reverse=True)
print(result1)
python基础

函数练习

1. 已经列表points中保存的是每个点的坐标(坐标是用元组表示的，第一个值是x坐标，第二个值是y坐标)

1
2
3
points = [
  (10, 20), (0, 100), (20, 30), (-10, 20), (30, -100)
]

以下问题使用实参高阶函数来解决

1）获取列表中y坐标最大的点

1
2
result1 = max(points, key=lambda x:x[1])
print(result1)

2）获取列表中x坐标最小的点

1
2
result2 = min(points, key=lambda x:x[0])
print(result2)

3）获取列表中距离原点最远的点

1
2
result3 = max(points, key=lambda x:(x[0]**2 + x[1]**2)**0.5)
print(result3)

4）将点按照点到x轴的距离大小从大到小排序

1
2
result4 = sorted(points, key=lambda x:(x[1]**2),reverse=True)
print(result4)

2. 求列表 nums 中绝对值最大的元素

1
2
3
nums = [2,3,8,-9,5]
result2 = max(nums,key= lambda item : (item**2))
print(result2)

3. 已经两个列表A和B，用map函数创建一个字典，A中的元素是key，B中的元素是value

1
2
3
A = ['name', 'age', 'sex']
B = ['张三', 18, '女']
新字典: {'name': '张三', 'age': 18, 'sex': '女'}
1
2
3
4
A = ['name', 'age', 'sex']
B = ['张三', 18, '女']
result3 = map(lambda x,y: (x,y), A, B)
print(dict(result3))

4. 已经三个列表分别表示5个学生的姓名、学科和班号，使用map将这个三个列表拼成一个表示每个学生班级信息的的字典

1
2
3
4
names = ['小明', '小花', '小红', '老王']
nums = ['1906', '1807', '2001', '2004']
subjects = ['python', 'h5', 'java', 'python']
结果：{'小明': 'python1906', '小花': 'h51807', '小红': 'java2001', '老王': 'python2004'}
1
2
3
4
5
6
names = ['小明', '小花', '小红', '老王']
nums = ['1906', '1807', '2001', '2004']
subjects = ['python', 'h5', 'java', 'python']

result4 = map(lambda x,y,z: (x,z+y), names, nums,subjects)
print(dict(result4))

5. 已经一个列表message, 使用reduce计算列表中所有数字的和（用采用列表推导式和不采用列表推导式两种方法做）

1
2
message = ['你好', 20, '30', 5, 6.89, 'hello']
结果：31.89

不使用列表推导式

1
2
result5 = reduce(lambda item1,item2:item1+(item2 if type(item2) in [int,float] else 0) ,message,0)
print(result5)

使用列表推导式

1
2
result6 = reduce(lambda item1,item2:item1+item2,[x for x in message if type(x) in [int,float]],0)
print(result6)

6. 已知一个字典列表中保存的是每个学生各科的成绩，

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
studens = [
  {'name': 'stu1', 'math': 97, 'English': 67, 'Chinese': 80},
  {'name': 'stu2', 'math': 56, 'English': 84, 'Chinese': 74},
  {'name': 'stu3', 'math': 92, 'English': 83, 'Chinese': 78},
  {'name': 'stu4', 'math': 62, 'English': 90, 'Chinese': 88}
]

# 计算平均分
studens = [
  {'name': 'stu1', 'math': 97, 'English': 67, 'Chinese': 80, 'avg':81},
  {'name': 'stu2', 'math': 56, 'English': 84, 'Chinese': 74, 'avg':71},
  {'name': 'stu3', 'math': 92, 'English': 83, 'Chinese': 78, 'avg':87},
  {'name': 'stu4', 'math': 62, 'English': 90, 'Chinese': 88, 'avg':80}
]

# 按照平均分从高到低排序
...

1）计算并添加每个学生的平均分

1
2
3
4
5
from functools import reduce
for student in studens:
    result = (reduce(lambda x,y:x+y,list(student.values())[1:],0))//3
    student['avg'] = result
print(studens)

2）按照平均分从高到低排序

1
2
result1 = sorted(studens,key= lambda x:x['avg'],reverse=True)
print(result1)
python基础

认识函数

1.认识函数

1.1什么是函数 - 实现某一特定功能的代码的封装，每个函数都有自己的特定功能

函数把实现某一个功能所有代码打了一个包,每次需要的时候，直接调用

2函数的分类(函数是由谁创建/定义来进行分类)

2.1系统函数 - python自定义函数,需要的时候直接调用

2.2自定义函数 - 由程序员直接创建

3.定义(创建)函数

3.1语法

1
2
3
4
5
6
7
8
def 函数名(形参列表):  
    函数说明文档      
    函数体 

## 函数名 - 是标识符,不是关键字,见名知意,字母小写(下划线隔开),不使用系统的函数名,类名,模块名    
## 形参列表 - 多个变量用逗号隔开,一个变量是一个形参,可以没有形参
## 形参的作用：将函数外部的数据传递函数到函数里面
## 实现函数功能的语句块

练习1 定义一个函数求两个数的和

1
2
def sum1(x,y):
    print(x+y)

练习2：定义一个函数获取指定整数的个位数

1
2
def qugewei(x):
    print(x % 10)

练习3：定义一个函数获取指定字符串中数字字符的个数

1
2
3
4
5
6
def count_str(str1):
    count1 = 0
    for item in str1:
        if '0' <= item <= '9':
            count1+=1
    print("该字符串中数字字符的个数为:",count1)

练习4：定义一个函数将两个字符串合并成一个字符串，合并方式如下：

‘abc’ 和 ‘123’ 合并为：’a1b2c3’

‘abcdef’ 和 ‘123’ 合并为：’a1b2c3def’

‘abc’ 和 ‘12345’ 合并为：’a1b2c345’

方法1

1
2
3
4
5
6
7
8
9
10
11
12
13
def sum_str(str1,str2):
    str3 = ''
    if len(str1) >= len(str2):
        for index in range(len(str2)):
            str3 += str1[index] + str2[index]
        str3 += str1[len(str2)::1]
        print(str3)
    else:
        for index in range(len(str1)):
            str3 += str1[index] + str2[index]
        str3 += str2[len(str1)::1]
        print(str3)
sum_str('abc','12345')

方法2

1
2
3
4
5
6
7
8
9
def mix_str(str1, str2):
    len1 = len(str1)
    len2 = len(str2)
    length = min(len1, len2)
    new_str = ''
    for index in range(length):
        new_str += str1[index] + str2[index]
    new_str += str1[length:] + str2[length:]
    print(new_str)

练习5：定义一个函数打印n的阶乘

1
2
3
4
5
def factorial(n):
    sum1 = 1
    for x in range(1,n+1):
        sum1 *= x
    print(sum1)

4.调用函数

4.1 定义函数不会执行函数体 - 调用函数的时候才会执行

4.2 语法 - 函数名(实参列表) 函数有形参,必须要传入实参,实参的个数必须和形参一致,且一一对应

5.位置参数和关键字参数

5.1位置参数 - 直接提供形参对应的数据,让实参和形参一一对应

5.2关键字参数 - 以’形参1 = 实参1, 形参2 = 实参2…的方式传参’

5.3位置参数和关键字参数混用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def func1(a, b, c):
    print(f'a:{a}, b:{b}, c:{c}')

# 位置参数
func1(100, 200, 300)    # a:100, b:200, c:300
func1(200, 100, 300)    # a:200, b:100, c:300

# 关键字参数
func1(a=100, b=200, c=300)    # a:100, b:200, c:300
func1(c=300, a=100, b=200)    # a:100, b:200, c:300

# 混用
func1(10, b=20, c=30)
func1(10, c=30, b=20)
func1(10, 20, c=30)

5.4参数默认值 - 定义函数时可以以 ‘形参名=值’ 的形式给形参提供默认值

有默认值的形参可以不传实参,如果不传实参,调用函数时,该形参使用默认值

1
2
3
4
5
6
def func1(a=10, b=20, c=30):
    print(f'a:{a}, b:{b}, c:{c}')
func1() #a:10, b:20, c:30
func1(100)  #a:100, b:20, c:30
func1(100,200)  #a:100, b:200, c:30
func1(c=300)  #a:10, b:20, c:300

如果定义函数时,部分参数有默认值,部分参数没有,没有默认值的参数必须在有默认值的前面

1
2
3
def func1(a, c, b=20):
    print(f'a:{a}, b:{b}, c:{c}')
func1(10,30)

6.参数类型说明

6.1有默认值的参数:默认值是什么类型,类型说明就是什么类型

6.2没有默认值的参数,需要在形参后面加 ‘:类型名’

1
2
3
def func4(x: list, y=''):
    print(x, y)
func4([1, 2, 3], 'abc')

7.不定长参数

7.1带的不定长参数 - 在形参前加,那么这个形参就可以接收任意多个实参

7.2带*的不定长参数本质就是一个元组,对应的多个实参是元组中的元素

7.3带*的不定长参数,传参的时候必须使用位置参数

7.4如果定长的参数在带*的参数后面(后面的定长参数调用时必须用关键字参数传参)

1
2
3
4
5
def func5(*x):
    print(x)
func5()
func5(4)
func5(4, 5)

7.5带两个*的不定长参数

1
2
3
4
5
6
def func9(**x):
    print(x)

func9()
func9(a=10)
func9(a=10 ,b=20 ,c=30)

8.函数返回值

8.1返回值就是将函数内部产生的数据传递到函数的外部

8.2函数的功能产生的新的数据时,就可以将新的数据作为返回值返回

8.3在函数体中通过return返回数据 - return 数据

8.4在函数外面如何使用返回值 - 函数调用表达式的值就是获取函数的返回值

8.5return 具有提前结束函数的功能,遇到return之后函数执行结束

8.6当没有返回值时,函数表达式的值为none

1
2
3
4
5
def sum1(num1, num2):
    s = num1 + num2
    return s

print(sum1(10, 20))
1
2
3
4
5
6
7
8
def func4(x):
    if x % 2:
        return 100
    print("aaa")

print('返回值：',func4(20))
print("="*30)
print('返回值：',func4(21))

作业

1. 编写一个函数，交换指定字典的key和value。

1
例如:dict1={'a':1, 'b':2, 'c':3}  -->  dict1={1:'a', 2:'b', 3:'c'}  
1
2
3
4
5
6
def change1(dict1:dict):
    new_dict1 = {}
    for key in dict1:
        new_dict1[dict1[key]] = key
    print(new_dict1)
change1({'a':1, 'b':2, 'c':3})

2. 编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串

1
例如: 传入'12a&bc12d-+'   -->  'abcd'  
1
2
3
4
5
6
7
def get_zimu(str1):
    new_str1 = ''
    for item in str1:
        if 'a' <= item <= 'z' or 'A' <= item <= 'Z':
            new_str1+=item
    print(new_str1)
get_zimu('aldliaw142415weif')

3. 写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母

1
例如: 'abc' -> 'Abc'   '12asd'  --> '12asd'
1
2
3
4
5
6
7
8
9
10
11
def capitalize1(str1):
    new_str1 = ''
    if 'a' <= str1[0] <= 'z':
        new_str1 += chr(ord(str1[0]) - 32)
    for index in range(1,len(str1)):
        if 'A' <= str1[index] <= 'Z':
            new_str1 += chr(ord(str1[index]) + 32)
        else:
            new_str1 += str1[index]
    print(new_str1)
capitalize1('wfxMYdfewe')

4. 写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束

1
2
例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True
     字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: False
1
2
3
4
5
6
7
8
9
10
11
def endswith1(str1):
    str5 = 'c'
    if str5 not in str1:
        print(False)
    else:
        if str5 == str1[-len(str5)::1]:
            print(True)
        else:
            print(False)

endswith1('ababcdc')

5. 写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串

1
2
3
例如: '1234921'  结果: True
      '23函数'   结果: False
      'a2390'    结果: False
1
2
3
4
5
6
7
8
9
def isdigit1(str1:str):
    for item in str1:
        if not '0' <= item <= '9':
            print(False)
            break
    else:
        print(True)

isdigit1('123456')

6. 写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母

1
例如: 'abH23好rp1'   结果: 'ABH23好RP1'   
1
2
3
4
5
6
7
8
9
def upper1(str1):
    new_str1 = ''
    for i in str1:
        if 'a' <= i <= 'z':
            new_str1 += i.upper()
        else:
            new_str1+=i
    print(new_str1)
upper1('a2h2klm12+')

7. 写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充

1
2
例如: 原字符:'abc'  宽度: 7  字符:'^'    结果: '^^^^abc'
     原字符:'你好吗'  宽度: 5  字符:'0'    结果: '00你好吗'

8. 写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1

1
2
3
例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0]  元素: 1   结果: 0,4,6  
     列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '赵云'   结果: 0,4
     列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '关羽'   结果: -1         
1
2
3
4
5
6
7
8
9
10
def index1(list1,item):
    count = 0
    for i in list1:
        if i == item:
            print(count, end=',')
        count += 1
    if count == 0:
        print('-1')

index1([1, 2, 45, 'abc', 1, '你好', 1, 0],1)

9. 写一个自己的len函数，统计指定序列中元素的个数

1
2
3
例如: 序列:[1, 3, 5, 6]    结果: 4
     序列:(1, 34, 'a', 45, 'bbb')  结果: 5  
     序列:'hello w'    结果: 7

10. 写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值

 
1
2
3
例如: 序列:[-7, -12, -1, -9]    结果: -1   
     序列:'abcdpzasdz'    结果: 'z'  
     序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98}   结果: 98

11. 写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在

 
1
2
例如: 序列: (12, 90, 'abc')   元素: '90'     结果: False
     序列: [12, 90, 'abc']   元素: 90     结果: True

12. 写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串

1
2
3
```python
    例如: 原字符串: 'how are you? and you?'   旧字符串: 'you'  新字符串:'me'  结果: 'how are me? and me?'
```
python基础

字符串练习

  1. 编写一个函数，交换指定字典的key和value。 

    1
    例如:dict1={'a':1, 'b':2, 'c':3}  -->  dict1={1:'a', 2:'b', 3:'c'}  
    1
    2
    3
    4
    5
    6
    def change1(dict1:dict):
        new_dict1 = {}
        for key in dict1:
            new_dict1[dict1[key]] = key
        return new_dict1
    print(change1({'a':1, 'b':2, 'c':3}))

  2. 编写一个函数，提取指定字符串中所有的字母，然后拼接在一起产生一个新的字符串 

    1
    例如: 传入'12a&bc12d-+'   -->  'abcd'  
    1
    2
    3
    4
    5
    6
    7
    def get_zimu(str1):
        new_str1 = ''
        for item in str1:
            if 'a' <= item <= 'z' or 'A' <= item <= 'Z':
                new_str1+=item
        return new_str1
    print(get_zimu('aldliaw142415weif'))

  3. 写一个自己的capitalize函数，能够将指定字符串的首字母变成大写字母

    1
    例如: 'abc' -> 'Abc'   '12asd'  --> '12asd'
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    def capitalize1(str1):
        new_str1 = ''
        if 'a' <= str1[0] <= 'z':
            new_str1 += chr(ord(str1[0]) - 32)
        for index in range(1,len(str1)):
            if 'A' <= str1[index] <= 'Z':
                new_str1 += chr(ord(str1[index]) + 32)
            else:
                new_str1 += str1[index]
        return new_str1
    print(capitalize1('wfxMYdfewe'))

  4. 写一个自己的endswith函数，判断一个字符串是否已指定的字符串结束 

    1
    2
    例如: 字符串1:'abc231ab' 字符串2:'ab' 函数结果为: True
         字符串1:'abc231ab' 字符串2:'ab1' 函数结果为: False
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    def endswith1(str1):
        str5 = 'c'
        if str5 not in str1:
            print(False)
        else:
            if str5 == str1[-len(str5)::1]:
                print(True)
            else:
                print(False)

    endswith1('ababcdc')

  5. 写一个自己的isdigit函数，判断一个字符串是否是纯数字字符串 

    1
    2
    3
    例如: '1234921'  结果: True
          '23函数'   结果: False
          'a2390'    结果: False
    1
    2
    3
    4
    5
    6
    7
    8
    9
    def isdigit1(str1:str):
        for item in str1:
            if not '0' <= item <= '9':
                print(False)
                break
        else:
            print(True)

    isdigit1('123456')

  6. 写一个自己的upper函数，将一个字符串中所有的小写字母变成大写字母

    1
    例如: 'abH23好rp1'   结果: 'ABH23好RP1'   
    1
    2
    3
    4
    5
    6
    7
    8
    9
    def upper1(str1):
        new_str1 = ''
        for i in str1:
            if 'a' <= i <= 'z':
                new_str1 += i.upper()
            else:
                new_str1+=i
        return new_str1
    print(upper1('a2h2klm12+'))

  7. 写一个自己的rjust函数，创建一个字符串的长度是指定长度，原字符串在新字符串中右对齐，剩下的部分用指定的字符填充 

    1
    2
    例如: 原字符:'abc'  宽度: 7  字符:'^'    结果: '^^^^abc'
         原字符:'你好吗'  宽度: 5  字符:'0'    结果: '00你好吗'
    1
    2
    3
    4
    5
    6
    7
    8
    9
    def rjust1(str1,width,str2):
        new_str1 = ''
        if len(str1) >= width:
            new_str1 += str1
        else:  ### 下面出现的'+'为填充字符可以自定义,默认空格
            new_str1 = str2 * (width - len(str1)) + str1
        return new_str1

    print(rjust1('你好吗',5,'0'))

  8. 写一个自己的index函数，统计指定列表中指定元素的所有下标，如果列表中没有指定元素返回-1

    1
    2
    3
    例如: 列表: [1, 2, 45, 'abc', 1, '你好', 1, 0]  元素: 1   结果: 0,4,6  
         列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '赵云'   结果: 0,4
         列表: ['赵云', '郭嘉', '诸葛亮', '曹操', '赵云', '孙权']  元素: '关羽'   结果: -1         
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    def index1(list1,item):
        count = 0
        str1 = ''
        for i in list1:
            if i == item:
                str1 += str(count) + ','
            count += 1
        else:
            if count == 0:
                return -1
        return str1[0:len(str1)-1]
    print(index1([1, 2, 45, 'abc', 1, '你好', 1, 0],1))

  9. 写一个自己的len函数，统计指定序列中元素的个数 

    1
    2
    3
    例如: 序列:[1, 3, 5, 6]    结果: 4
         序列:(1, 34, 'a', 45, 'bbb')  结果: 5  
         序列:'hello w'    结果: 7
    1
    2
    3
    4
    5
    6
    7
    def len1(xulie):
        count = 0
        for item in xulie:
            count+=1
        print("该序列的元素个数为：",count)

    len1((1,2,'d','b'))

  10. 写一个自己的max函数，获取指定序列中元素的最大值。如果序列是字典，取字典值的最大值

    1
    2
    3
    例如: 序列:[-7, -12, -1, -9]    结果: -1   
         序列:'abcdpzasdz'    结果: 'z'  
         序列:{'小明':90, '张三': 76, '路飞':30, '小花': 98}   结果: 98
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    def max1(xulie):
        if type(xulie) == dict:
            max_num = 0
            for key in xulie:
                if xulie[key] > max_num:
                    max_num = xulie[key]
        else:
            max_num = xulie[0]
            for item in xulie:
                if item > max_num:
                    max_num = item
        print("最大值为：",max_num)

    max1({'小明':90, '张三': 76, '路飞':30, '小花': 98})

  11. 写一个函数实现自己in操作，判断指定序列中，指定的元素是否存在 

     
    1
    2
    例如: 序列: (12, 90, 'abc')   元素: '90'     结果: False
         序列: [12, 90, 'abc']   元素: 90     结果: True     
    

    1
    2
    3
    4
    5
    6
    7
    8
    9
    def in1(xulie,item):
        for i in xulie:
            if i == item:
                print(True)
                break
        else:
            print(False)

    in1([12, 90, 'abc'],90)

  12. 写一个自己的replace函数，将指定字符串中指定的旧字符串转换成指定的新字符串 

     
    1
    例如: 原字符串: 'how are you? and you?'   旧字符串: 'you'  新字符串:'me'  结果: 'how are me? and me?'
    

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    def replace1(str1, str2, str3):
        num1 = 0
        num2 = len(str2)
        new_str = ''
        while num1 <= len(str1) - 1:
            if str1[num1:num2] == str2:
                new_str += str3
                num1 += 3
                num2 += 3
            else:
                new_str += str1[num1]
                num1 += 1
                num2 += 1
        print(new_str)
    replace1('how are you? and you?','you','me')
python基础

python基础练习题

Python基础练习题

一、选择题

  1. 下面不属于 Python 特性的是（C）

    A. 简单易学

    B. 开源的免费的

    C. 属于低级语言

    D. 高可移植性

  2. Python脚本文件的扩展名是（B）

    A. .python

    B. .py

    C. .pt

    D. pg

  3. 当需要在字符串中使用特殊字符时，python 使用（A）。

    A. \

    B. /

    C. #

    D. %

  4. 下面（D）不是有效的变量名。

    A. _demo

    B. banana

    C. Number

    D. My-score

  5. 幂运算运算符为（B）。

    A. *

    B. **

    C. %

    D. //

  6. 优先级最高的运算符为（D）。

    A. /

    B. //

    C. *

    D. ()

  7. 下面程序的运行结果为（B）。

    1
    2
    3
    4
    5
    list1 = [1, 2]
    temp = list1[0]
    list1[0] = list1[1]
    list1[1] = temp
    print(list1)

    A. [1, 2]

    B. [2, 1]

    C. [2. 2]

    D. [1, 1]

  8. 下列哪个语句在Python中是非法的？（B）

    A. x = y = z = 1

    B. x = (y = z + 1)

    C. x, y = y, x

    D. x += y x=x+y

  9. 关于Python内存管理，下列说法错误的是（B）。

    A. 变量不必事先声明

    B. 变量无须先创建和赋值而直接使用

    C. 变量无须指定类型

    D. 可以使用del释放资源

  10. 以下不能创建一个字典的语句是（C）。

    A. dict1 = {}

    B. dict2 = {3: 5}

    C. dict3 = dict([2, 5], [3, 4])

    D. dict4 = dict(([2, 5], [3, 4]))

二、编程题

1. 基础题

  1. 将一个列表的数据复制到另一个列表中。

    1
    2
    3
    4
    5
    list1=[1,2,4,5]
    list2=[]
    for item in list1:
        list2.append(item)
    print(list2)

  2. 利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    scores = float(input("请输入一个分数:"))
    if 100 >= scores >=90:
        print('A')
    elif 90 > scores >=60:
        print('B')
    elif 60 > scores >=0:
        print('C')
    else:
        print('分数有问题')

  3. 输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    str1 = 'qfiewo 1312  fwqjl#*|'
    count_english = 0
    count_space = 0
    count_nums = 0
    other = 0
    for item in str1:
        if 'a' <= item <= 'z' or 'A' <= item <= 'Z':
            count_english+=1
        elif item == " ":
            count_space+=1
        elif '0' <= item <= '9':
            count_nums+=1
        else:
            other+=1
    print("其中英文字母有%s个,空格有%s个,数字有%s个,其它字符有%s个" % (count_english,count_space,count_nums,other))

  4. 将所输入的5个字符，以相反顺序打印出来。

    1
    2
    str1 = input("请输入五个字符：")
    print(str1[-1::-1])

  5. 给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字。

    1
    2
    3
    4
    5
    6
    7
    nums = input("请输入一个五位数及以下的数字：")
    print("逆序输出：",nums[-1::-1])
    count = 0
    while int(nums):
        nums = int(nums) // 10
        count += 1
    print("他是一个",count,"位数")

  6. 一个5位数，判断它是不是回文数。即12321是回文数，个位与万位相同，十位与千位相同。

    1
    2
    3
    4
    5
    6
    nums = 22322
    if nums % 10 == nums // 10000:
        if nums // 10 % 10 == nums // 1000 % 10:
            print("是回文数")
    else:
        print("不是回文数")

  7. 按逗号分隔列表。

    [1,2,3,4,5] -> 1,2,3,4,5

    1
    2
    3
    4
    5
    6
    list1 = [1,2,3,4,5]
    for index in range(len(list1)):
        if index == len(list1) - 1:
            print(list1[index])
        else:
            print(list1[index],end=',')

  8. 求一个3*3矩阵主对角线元素之和。

    1
    2
    3
    4
    5
    6
    7
    例如，列表如下：
    [
      [1, 2, 3],
     	[4, 5, 6],
     	[7, 8, 9]
    ]
    求： 1+ 5+ 9 的和
    1
    2
    3
    4
    5
    6
    list2 = [
         [1, 2, 3],
        	[4, 5, 6],
        	[7, 8, 9]
       ]
    print(list2[0][0] + list2[1][1] + list2[2][2])

  9. 有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。

    例如：原列表为[10, 20, 34, 56, 90], 输入 50 后，列表为：[10, 20, 34, 50, 56, 90]

    1
    2
    3
    4
    5
    6
    7
    8
    9
    list3 = [10, 20, 34, 56, 90]
    item = int(input("请输入一个整数："))
    for index in range(len(list3)):
        if list3[index] > item:
            list3.insert(index,item)
            break
    else:
        list3.append(item)
    print(list3)

  10. 两个 3 行 3 列的矩阵，实现其对应位置的数据相加，并返回一个新矩阵：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    X = [[12,7,3],
        [4 ,5,6],
        [7 ,8,9]]

    Y = [[5,8,1],
        [6,7,3],
        [4,5,9]]

    X + Y 为：
    [
      [17, 15, 4],
      [10, 12, 9],
      [11, 13, 18]
    ]
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    X = [
        [12,7,3],
         [4 ,5,6],
         [7 ,8,9]
    ]

    Y = [
        [5,8,1],
        [6,7,3],
        [4,5,9]
    ]
    W = []
    for index1 in range(len(X)):
        Z = []
        for index2 in range(len(X[index1])):
            Z.append(X[index1][index2] + Y[index1][index2])
        W.append(Z)
    print(W)

  11. 求输入数字的平方，如果平方运算后小于 50 则退出。

    1
    2
    3
    4
    5
    6
    7
    8
    def chongfu():
        nums = int(input("请输入一个整数:"))
        if nums ** 2 > 50:
            print(nums**2)
        else:
            exit()
        chongfu()
    chongfu()

  12. 两个变量值互换。

    1
    2
    3
    4
    x = 'www'
    y = 5
    x,y = y,x
    print(x,y)

2. 进阶题

  1. 有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    num_list = [1,2,3,4]
    count = 0
    for i in range(len(num_list)):
        for j in range(len(num_list)):
            for k in range(len(num_list)):
                a = num_list[i]
                b = num_list[j]
                c = num_list[k]
                if a != b and a != c and b != c:
                    print(num_list[i] * 100 + num_list[j] * 10 + num_list[k])
                    count += 1
    print("一共可以组成%s个不重复的三位数" % count)

  2. 企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润I，求应发放奖金总数？

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    profit = int(input("请输入当月利润："))
    bonus = 0
    if profit>100:
        bonus = 10*(0.1+0.075)+(20*0.05+0.03)+40*0.015+(profit-100)*0.01
    elif profit>60:
        bonus = 10*(0.1+0.075)+(20*0.05+0.03)+(profit-60)*0.015
    elif profit>40:
        bonus = 10 * (0.1 + 0.075) + 20 * 0.05 + (profit-40)*0.03
    elif profit>20:
        bonus = 10 * (0.1 + 0.075) + (profit-20)*0.05
    elif profit>10:
        bonus = 10*0.1 +(profit-10)*0.075
    else:
        bonus = profit*0.1
    print(bonus)

  3. 一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？

    1
    2
    3
    4
    5
    6
    import math
    for i in range(10000):
        x = int(math.sqrt(i + 100))
        y = int(math.sqrt(i + 100 + 168))
        if (x * x == i + 100) and (y * y == i + 100 + 168):
            print(i)

  4. 输出 9*9 乘法口诀表。(需要对齐)

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

  5. 古典问题：有一对兔子，从出生后第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)

  6. 一个数如果恰好等于它的因子之和，这个数就称为”完数”。例如6=1＋2＋3.编程找出1000以内的所有完数。

    1
    2
    3
    4
    5
    6
    7
    for x in range(2,1001):
        sum = 1
        for i in range(2,x):
            if x%i==0:
                sum+=i
        if sum==x:
            print(x)

  7. 一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

    1
    2
    3
    4
    5
    6
    height = 100
    count = 0
    for i in range(10):
        count+=height
        height /= 2
    print("共经过%s米,第十次反弹%s米" % (count,height))

  8. 打印出如下图案（菱形）:

    1
    2
    3
    4
    5
    6
    7
       *
      ***
     *****
    *******
     *****
      ***
       *
    1
    2
    3
    4
    5
    6
    7
    n = 1
    k = 2
    while n >= 0:
        print(int((7 - n) / 2) * ' ' + '*' * n)
        n += k
        if n == 7:
            k = -k

  9. 有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13…求出这个数列的前20项之和。

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

  10. 打印出杨辉三角形（要求打印出10行如下图）。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    1 
    1 1 
    1 2 1 
    1 3 3 1 
    1 4 6 4 1 
    1 5 10 10 5 1 
    1 6 15 20 15 6 1 
    1 7 21 35 35 21 7 1 
    1 8 28 56 70 56 28 8 1 
    1 9 36 84 126 126 84 36 9 1
python基础

字符串格式化

字符串格式化

1.字符串格式占位符

数据和格式占位符一一对应

1
2
3
4
%s - 字符串占位符 - 可以给任何类型的数据站位
%d - 整数占位符 - 只能给数字占位,如果是浮点数会去除小数点后面的数
%f - 浮点数占位符 - 只能给数字占位,默认保留6位小数
%.Nf - 浮点数占位符,只能给数字占位,保留N位小数
1
2
3
4
5
6
7
name = '小明'
age = 18
gender = '男'
money = 19999.9

message = '%s今年%d岁,性别:%s,月薪是:%s元' % (name,age,gender,money)
print(message)

2.f-string

在字符串外面加f,里面就可以通过{表达式} 来为字符串指定位置赋值

2.1基本用法：{提供数据的表达式}

2.2加参数：{提供数据的表达式:参数}

2.2.1 - :, - 数字数据在显示时以银行显示金额的方式显示,(每三位以逗号隔开)(用于数字数据)

2.2.2 - :.N% - 数字数据以百分比方式显示, .N控制小数位数,默认为6位小数,可以不写

2.2.3 - :.Nf - 直接控制小数位数,由N控制

2.2.4 - :x>N - 相当于rjust x 表示填充字符,不给是空格,N是填充后的长度

2.2.5 - :x<N - 相当于ljust x 表示填充字符,不给是空格,N是填充后的长度

2.2.6 - :x^N - 相当于center x 表示填充字符,不给是空格,N是填充后的长度

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
name = '小明'
age = 18
gender = '男'
money = 99999999

# message = f'{name}今年{age}岁,性别:{gender},月薪:{money}元'
# message = f'{name}今年{age}岁,性别:{gender},月薪:{money:,}元,增长率:{0.2344:%}'
message = f'{name}今年{age}岁,性别:{gender},月薪:{money:,}元,增长率:{0.2344:.2%}'
print(message)


a = 100
list1 = [10,20,30]
message = f'a:{a},ax10:{a*10},d:{list1},e:{list1[0]},f:{[i for i in list1 if i <=20]}'
print(message)

print(f'数字:{"abc":a>5}')
### 数字:aaabc 其中a可以不给,就是空格

总结 - 容器型数据类型

1.区分不同容器的应用场景(列表,元组,集合,字典,字符串,range)

1.1容器的本质:能够同时保存多个数据

1.1.1 字符串和range - 不适合作为容器来保存多个别的数据

a.字符串 - 只能以字符为单位保存多个文字符号

b.range - 只能存储等差数列的数据(程序只能控制范围和差)

1.1.2 列表,元组,集合,字典 - 都可以存储通过别的方式提供的多个数据

a.列表,字典 - 同时保存多个数据的最好选择(意义相同的数据用列表,反之用字典)

b.元组 - 特点:不可变!要求多个数据存储到容器中以后不能修改

c.集合 - 去重,数学集合运算

2.拷贝和不拷贝的问题

2.1 为什么元组没有copy()方法(不可变的数据拷贝没有意义)

1
2
python存储数据的底层逻辑
数据保存在堆里面,变量在栈里面,变量保存的是数据在堆中的地址

2.2 可变数据类型的变量直接赋值和拷贝的区别

直接用一个变量给另外一个变量赋值,是将这个变量保存的地址复制给另一个变量

拷贝会生成一份新的内存地址

3.怎么判断是否需要获取函数或者方法的结果

1
2
3
4
5
6
7
8
9
10
### 获取使用结果
list1 = [20,10,30,40,20,50]
result = list1.count(20)
print(result)

## 不获取,不使用方法的结果

result2 = list1.append(100)
print(list1)
print(result2)  ##None 没有意义,不获取不使用方法的结果

扩展id函数:id(数据/变量) - 获取数据在内存中的地址/变量直接存储的地址

多个相同的不可变数据在内存中只保留一个

多个相同的可变数据在内存中保留多个

1
2
3
4
num = 100
age = 100
print(id(num),id(age))
##140711439569680 140711439569680
python基础

字符串练习

1. 输入一个字符串，打印所有奇数位上的字符(下标是1，3，5，7…位上的字符)

例如: 输入**’abcd1234 ‘ ** 输出**’bd24’** 

1
2
3
4
5
6
str1 = 'abcd1234 '
new_str1 = ''
for index in range(len(str1)):
    if index % 2:
        new_str1+=str1[index]
print(new_str1)

2. 输入用户名，判断用户名是否合法(用户名长度6~10位)

1
2
3
4
5
a = input("请输入用户名:")
if 6 <= len(a) <=10:
    print("用户名合法")
else:
    print("用户名不合法")

3. 输入用户名，判断用户名是否合法(用户名中只能由数字和字母组成)

例如: ‘abc’ — 合法 ‘123’ — 合法 ‘abc123a’ — 合法

1
2
3
4
5
6
7
8
9
a = input("请输入用户名：")
for i in a:
    if '0' <= i <= '9' or 'a' <= i <= 'z':
        continue
    else:
        print('不合法')
        break
else:
    print('合法')

4. 输入用户名，判断用户名是否合法(用户名必须包含且只能包含数字和字母，并且第一个字符必须是大写字母)

例如: ‘abc’ — 不合法 ‘123’ — 不合法 ‘abc123’ — 不合法 ‘Abc123ahs’ — 合法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
a = input("请输入用户名：")
flag = False
if 'A' <= a[0] <= 'Z':
    flag = True
else:
    print('用户名不合法')
nums = 0
if flag:
    for i in a:
        if 'a' <= i <= 'z' or 'A' <= i <= 'Z' or '0' <= i <= '9':
            if '0' <= i <= '9':
                nums+=1
            continue
        else:
            print('用户名不合法')
            break
    else:
        if nums >=1:
            print('用户名合法')
        else:
            print('用户名不合法')

5. 输入一个字符串，将字符串中所有的数字字符取出来产生一个新的字符串

例如：输入**’abc1shj23kls99+2kkk’** 输出：**’123992’**

1
2
3
4
5
6
str1 = 'abc1shj23kls99+2kkk'
new_str1 = ''
for i in str1:
    if '0' <= i <= '9':
        new_str1+=i
print(new_str1)

6. 输入一个字符串，将字符串中所有的小写字母变成对应的大写字母输出 (用upper方法和自己写算法两种方式实现)

例如: 输入**’a2h2klm12+’ ** 输出 ‘A2H2KLM12+’

方法1

1
2
3
4
5
6
7
8
str1 = 'a2h2klm12+'
new_str1 = ''
for i in str1:
    if 'a' <= i <= 'z':
        new_str1+=chr(ord(i)-32)
    else:
        new_str1+=i
print(new_str1)

方法2

1
2
3
4
5
6
7
8
str1 = 'a2h2klm12+'
new_str1 = ''
for i in str1:
    if 'a' <= i <= 'z':
        new_str1 += i.upper()
    else:
        new_str1+=i
print(new_str1)

7. 输入一个小于1000的数字，产生对应的学号

例如: 输入**’23’，输出‘py1901023’** 输入**’9’, 输出‘py1901009’** 输入**’123’，输出‘py1901123’**

1
2
3
4
5
str1 = 'py1901'
a = input("请输入一个小于1000的数字：")
result = str1.ljust(9-len(a),'0')
result += a
print("对应的学号为：",result)

8. 输入一个字符串，统计字符串中非数字字母的字符的个数

例如: 输入**’anc2+93-sj胡说’** 输出:4 输入**’===’** 输出:3

1
2
3
4
5
6
7
8
str1 = input("请输入：")
count = 0
for i in str1:
    if 'a' <= i <= 'z' or 'A' <= i <= 'Z' or '0' <= i <= '9':
        continue
    else:
        count += 1
print("非数字字母的个数为：",count)

9. 输入字符串，将字符串的开头和结尾变成’+’，产生一个新的字符串

例如: 输入字符串**’abc123’, 输出‘+bc12+’**

1
2
3
str1 = input("请输入一个字符串：")
new_str1 = (str1[1:len(str1)-1]).center(len(str1),'+')
print("新的字符串为：",new_str1)

10. 输入字符串，获取字符串的中间字符

例如: 输入**’abc1234’** 输出:‘1’ 输入**’abc123’** 输出**’c1’**

1
2
3
4
5
a = input("请输入字符串:")
if len(a) % 2:
    print(a[len(a)//2])
else:
    print(a[len(a)//2-1],a[len(a)//2],sep='')

11. 写程序实现字符串函数find/index的功能(获取字符串1中字符串2第一次出现的位置)

例如: 字符串1为:how are you? Im fine, Thank you! , 字符串2为:you, 打印8

1
2
3
4
5
6
7
8
9
10
11
str1 = input("请输入字符串1：")
str2 = input("请输入字符串2：")
count = 0
if str2 in str1:
    for item in str1:
        count+=1
        if item == str2[0]:
            break
else:
    print("字符串2不在字符串1中")
print("字符串1中字符串2第一次出现的位置为：",count-1)

12. 获取两个字符串中公共的字符

例如: 字符串1为:abc123, 字符串2为: huak3 , 打印:公共字符有:a3

1
2
3
4
5
6
7
8
str1 = 'abca123'
str2 = 'huak3'
sum_str = ''
for i in str1:
    if i in str2:
        if i not in sum_str:
            sum_str+=i
print(sum_str)
python基础

字符串

字符串(str)

1.1字符串是容器型数据类型 标志’’或者’’’’’’或者””””””,引号中每个符号就是字符串的元素

1.2字符串内容换行时可以直接回车

1.3字符串不可变(不支持增删改),字符串有序(支持下标操作)

1.4引号中每个符号都是字符串的元素(又叫字符) 元素是任意的 空格也是一个字符

1.5分为普通字符和转义字符

1
2
3
4
5
str1 = '90,100'
str2 = "adwfef542"
str3 = '''abc
        123'''
str4 = 'abc\ndef'

2.1 字符串元素 - 字符

2.1.1转义字符

1
2
3
4
5
\n - 换行
\t - 水平制表符(相当于tab键)
\' - 表示一个普通的单引号
\" - 表示一个普通的双引号
\\ - 表示一个普通的反斜杠

\u 4位的十六进制数 - 编码字符

1
2
3
str5 = 'it\'s me!'
print(str5)
# it's me!

3.1 字符编码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1.计算机只能直接存储数字(而且保存的数字的二进制的补码),文字符号是不能直接存储到计算机的
为了让计算机具备存储文字符号的能力,我们给所有的文字符号对应了一个固定的数字
每次存储文字符号时就将之对应的数字存储起来
符号对应的数字就是符号的编码值 

2.编码表 - 保存符号和数字的对应关系表
1)ASCII码表 - 总共128个字符
2)Unicode 编码表 - 包含(ASCII码) - 又称万国码
a.中文范围 - 4e00 ~9fa5

3.编码值在python中的使用
a.chr函数：chr(编码值) - 获取编码值对应的字符
b.ord函数：ord(字符) - 获取字符的编码值
c.编码字符：\u4e00 4e00就是4位的十六进制
注意：python中需要字符的地方都必须使用长度为1的字符串赋值
1
2
3
4
5
6
7
8
9
# for i in range(0x4e00,0x9fa5):
#     print(chr(i))

# for i in range(0x4dc0,0x4dff):
#     print(chr(i))

# print(ord('徐'),ord('明'),ord('勇'))
# ## 24464 26126 21191
# print(chr(24464),chr(26126),chr(21191))

练习：将大写字母转换为对应的小写字母

1
2
3
4
c = 'F'
new_c = chr(ord(c)+32)
print(new_c)
## f

4.1 查 - 获取字符串的元素

字符串获取字符的语法和列表获取元素一模一样

1
2
3
str1 = 'abcdefg'
for index,item in enumerate(str1):
    print(index,item)

4.2 数学运算符：+,*

1
2
print('hello'+'world')
print('='*20)

练习：提取字符中的小写字母

1
2
3
4
5
6
str1 = 'ssjjf大山洞IE偶见覅额35665'
new_str1 = ''
for i in str1:
    if 97 <= ord(i) <=122:
        new_str1+=i
print(new_str1)

4.3 比较运算符

1)比较是否相等：==,!=

1
2
print('abc'=='abc')  ##True
print('acb' == 'abc')  ##False

2)比较大小：>,<,>=,<=

两个字符串比较大小是比较第一对不相等的字符的编码大小

1
2
print('Mnxy'>'ab') ##False
print('你好'>'hello') ##True

应用1

1
2
3
4
5
6
7
8

char = ?
判断是否是数字字符 '0' <= char <= '9'
判断是否是小写字母 'a' <= char <= 'z'
判断是否是大写字母 'A' <= char <= 'Z'
判断是否是字母 'a' <= char <= 'z' or 'A' <= char <= 'Z'
判断是否是中文 '\u4e00' <= char <= '\u9fa5'

练习2：

1
str3 = '你好loe--23=sks;M9JHkyu是-12山卡拉'

1)统计中文字符的个数

1
2
3
4
5
# count = 0
# for i in str3:
#     if '\u4e00' <= i <= '\u9fa5':
#         count += 1
# print(count)

2)打印字符串所有的数字字符

1
2
3
# for i in str3:
#     if '0' <= i <= '9':
#         print(i,end=' ')

3)提取字符串中所有的字母

1
2
3
4
5
new_str3 = ''
for i in str3:
    if 'a' <= i <= 'z' or 'A' <= i <= 'Z':
        new_str3 += i
print(new_str3)

5.1 in 和 not in

1
字符串1 in 字符串2 - 判断字符串2中是否包含字符串1(字符串1是否是字符串2的子串)
1
2
print('1' in 'abc123')  ##True
print('ac' in 'abc123') ##False

5.2 r语法(r-string) - 在字符串的面前加r/R

如果在字符串前加r/R,那么字符串中所有的转义字符的功能都会消失

1
2
str1 = r 'abc\n'
print(str1)

path = r’C:\Users\Public\Win’

print(path)

6.1 相关函数

1
2
3
4
len(字符串)
str(数据) - 将数据转换成字符串(任何类型的数据都可以转换成字符串)
# 转换的时候是在数据的打印值的外面加引号
eval(字符串) - 去掉字符串外面的引号,如果字符串中是一个正确的表达式,会计算其结果
1
2
3
4
5
6
7
8
9

str(100) #'100'
str([10,20,30]) # '[10, 20, 30]'
str({'a':10,'b':20}) #"{'a':10,'b':20}"

print(eval('100')) #100
print(eval('[10,20,30]')) ##[10, 20, 30]
print(eval('100+200'))  ##300

7.1 字符串的相关方法

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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
capitalize()
将字符串的第一个字符转换为大写
center(width, fillchar)
返回一个指定的宽度 width 居中的字符串，fillchar 为填充的字符，默认为空格。  
count(str, beg= 0,end=len(string))
返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
bytes.decode(encoding="utf-8", errors="strict")
Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。  
encode(encoding='UTF-8',errors='strict')
以 encoding 指定的编码格式编码字符串，如果出错默认报一个ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
endswith(suffix, beg=0, end=len(string))
检查字符串是否以 obj 结束，如果beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
expandtabs(tabsize=8)
把字符串 string 中的 tab 符号转为空格，tab 符号默认的空格数是 8 。
find(str, beg=0, end=len(string))
检测 str 是否包含在字符串中，如果指定范围 beg 和 end ，则检查是否包含在指定范围内，如果包含返回开始的索引值，否则返回-1
index(str, beg=0, end=len(string))
跟find()方法一样，只不过如果str不在字符串中会报一个异常。
isalnum()
如果字符串至少有一个字符并且所有字符都是字母或数字则返 回 True，否则返回 False
isalpha()
如果字符串至少有一个字符并且所有字符都是字母或中文字则返回 True, 否则返回 False
isdigit()
如果字符串只包含数字则返回 True 否则返回 False..
islower()
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
isnumeric()
如果字符串中只包含数字字符，则返回 True，否则返回 False
isspace()
如果字符串中只包含空白，则返回 True，否则返回 False.
istitle()
如果字符串是标题化的(见 title())则返回 True，否则返回 False
isupper()
如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
join(seq)
以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
len(string)
返回字符串长度
ljust(width[, fillchar])
返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串，fillchar 默认为空格。
lower()
转换字符串中所有大写字符为小写.
lstrip()
截掉字符串左边的空格或指定字符。
maketrans()
创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
max(str)
返回字符串 str 中最大的字母。
min(str)
返回字符串 str 中最小的字母。
replace(old, new [, max])
把 将字符串中的 old 替换成 new,如果 max 指定，则替换不超过 max 次。
rfind(str, beg=0,end=len(string))
类似于 find()函数，不过是从右边开始查找.
rindex( str, beg=0, end=len(string))
类似于 index()，不过是从右边开始.
rjust(width,[, fillchar])
返回一个原字符串右对齐,并使用fillchar(默认空格）填充至长度 width 的新字符串
rstrip()
删除字符串末尾的空格或指定字符。
split(str="", num=string.count(str))
以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num+1 个子字符串
splitlines([keepends])
按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
startswith(substr, beg=0,end=len(string))
检查字符串是否是以指定子字符串 substr 开头，是则返回 True，否则返回 False。如果beg 和 end 指定值，则在指定范围内检查。
strip([chars])
在字符串上执行 lstrip()和 rstrip()
swapcase()
将字符串中大写转换为小写，小写转换为大写
title()
返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
translate(table, deletechars="")
根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
upper()
转换字符串中的小写字母为大写
zfill (width)
返回长度为 width 的字符串，原字符串右对齐，前面填充0 
isdecimal()
检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

7.2 join

字符串.join(序列) - 将序列中的元素用指定的字符串拼接成一个字符串(序列中的元素必须是字符串)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
list1 = ['abc','def','123']
result = ''.join(list1)
print(result)
## abcdef123
result2 = '+'.join(list1)
print(result2)
## abc+def+123
result3 = '123'.join(list1)
print(result3)
## abc123def123123
list2 = ['abc',100,True,'hello']
result4 = ''.join([str(x) for x in list2])
print(result4)
## abc100Truehello
## 如果拼接对象中有不是字符串的元素,需要转换成字符串

练习2：将list2中所有的字符串拼接成一个字符串

1
2
3
list2 = ['abc', 100, True, 'hello']     # abchello
result = ''.join([x for x in list2 if type(x)==str])
print(result)

7.3 count

字符串1.count(字符串2) - 统计字符串1在字符串2中出现的次数

1
2
3
message = 'how are you? i am fine! thank you! and you?'
result = message.count('you')
print(result)

7.4 index/find

字符串1.index(字符串2) - 获取字符串2第一次出现在字符串1中的位置(下标)

1
2
3
4
5
6
7
8
9
10
11
12
message = 'how are you? i am fine! thank you! and you?'
result = message.index('you')
print(result)
## 在字符串不存在时,会报错

result1 = message.find('you')
print(result1)
## 在字符串不存在时,不报错,并且返回-1

result2 = message.rfind('you')
print(result2)
## 获取字符串2最后一次出现在字符串1中的位置(下标)

7.5 split

字符串1.split(字符串2) - 将字符串1中所有的字符串2作为切割点对字符串1进行切割

切完后的结果是列表保存每一个小字符串，小字符串的个数是字符串2在字符串1中的个数加1

1
2
3
4
message = 'mnabc123abcxyzabcoop'
result1 = message.split('abc')
print(result1)
## ['mn', '123', 'xyz', 'oop']

字符串1.split(字符串2,n) - 最多切割n次

1
2
3
4
message = 'mnabc123abcxyzabcoop'
result2 = message.split('abc',1)
print(result2)
## ['mn', '123abcxyzabcoop']

8.1 replace

字符串1.replace(字符串2,字符串3)

将字符串1中的所有的字符串2替换成字符串3

1
2
3
message = 'how are you? i am fine! thank you! and you?'
result = message.replace('you','me')
print(result)

字符串1.replace(字符串2,字符串3,n)

将字符串1中的所有的字符串2替换成字符串3 n限制替换次数

1
2
3
message = 'how are you? i am fine! thank you! and you?'
result = message.replace('you','me',2)
print(result)

9.1 center\rjust\ljust\zfill

字符串1.center(总长度,填充字符) - 将字符串1转换成指定长度的新字符串,不够的用指定字符填充

1
2
3
4
5
str1 = 'abc' #000abc000
print(str1.center(9,'0'))  #000abc000
print(str1.center(8,'x'))  #xxabcxxx
print(str1.rjust(8,'x'))  #xxxxxabc
print(str1.ljust(8,'x'))  #abcxxxxx

zfill 与rjust方法相同 填充字符固定为’0’ - 字符串1.rjust(总长度,’0’)

10.1 strip/rstrip/lstrip 删除空白

1
2
3
4
5
6
7
8
9
10
11
str1 = '\t   abc  123   \n'
print(str1)
print('-'*20)
print(str1.strip())
## 删除两边空白
print('-'*20)
print(str1.lstrip())
## 删除左边空白
print('-'*20)
print(str1.rstrip())
## 删除右边空白

作业

1. 输入一个字符串，打印所有奇数位上的字符(下标是1，3，5，7…位上的字符)

例如: 输入**’abcd1234 ‘ ** 输出**’bd24’** 

1
2
3
4
5
6
str1 = 'abcd1234 '
new_str1 = ''
for index in range(len(str1)):
    if index % 2:
        new_str1+=str1[index]
print(new_str1)

2. 输入用户名，判断用户名是否合法(用户名长度6~10位)

1
2
3
4
5
a = input("请输入用户名:")
if 6 <= len(a) <=10:
    print("用户名合法")
else:
    print("用户名不合法")

3. 输入用户名，判断用户名是否合法(用户名中只能由数字和字母组成)

例如: ‘abc’ — 合法 ‘123’ — 合法 ‘abc123a’ — 合法

1
2
3
4
5
6
7
8
9
a = input("请输入用户名：")
for i in a:
    if '0' <= i <= '9' or 'a' <= i <= 'z':
        continue
    else:
        print('不合法')
        break
else:
    print('合法')

4. 输入用户名，判断用户名是否合法(用户名必须包含且只能包含数字和字母，并且第一个字符必须是大写字母)

例如: ‘abc’ — 不合法 ‘123’ — 不合法 ‘abc123’ — 不合法 ‘Abc123ahs’ — 合法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
a = input("请输入用户名：")
flag = False
if 'A' <= a[0] <= 'Z':
    flag = True
else:
    print('用户名不合法')
nums = 0
if flag:
    for i in a:
        if 'a' <= i <= 'z' or 'A' <= i <= 'Z' or '0' <= i <= '9':
            if '0' <= i <= '9':
                nums+=1
            continue
        else:
            print('用户名不合法')
            break
    else:
        if nums >=1:
            print('用户名合法')
        else:
            print('用户名不合法')

5. 输入一个字符串，将字符串中所有的数字字符取出来产生一个新的字符串

例如：输入**’abc1shj23kls99+2kkk’** 输出：**’123992’**

1
2
3
4
5
6
str1 = 'abc1shj23kls99+2kkk'
new_str1 = ''
for i in str1:
    if '0' <= i <= '9':
        new_str1+=i
print(new_str1)

6. 输入一个字符串，将字符串中所有的小写字母变成对应的大写字母输出 (用upper方法和自己写算法两种方式实现)

例如: 输入**’a2h2klm12+’ ** 输出 ‘A2H2KLM12+’

方法1

1
2
3
4
5
6
7
8
str1 = 'a2h2klm12+'
new_str1 = ''
for i in str1:
    if 'a' <= i <= 'z':
        new_str1+=chr(ord(i)-32)
    else:
        new_str1+=i
print(new_str1)

方法2

1
2
3
4
5
6
7
8
str1 = 'a2h2klm12+'
new_str1 = ''
for i in str1:
    if 'a' <= i <= 'z':
        new_str1 += i.upper()
    else:
        new_str1+=i
print(new_str1)

7. 输入一个小于1000的数字，产生对应的学号

例如: 输入**’23’，输出‘py1901023’** 输入**’9’, 输出‘py1901009’** 输入**’123’，输出‘py1901123’**

1
2
3
4
5
str1 = 'py1901'
a = input("请输入一个小于1000的数字：")
result = str1.ljust(9-len(a),'0')
result += a
print("对应的学号为：",result)

8. 输入一个字符串，统计字符串中非数字字母的字符的个数

例如: 输入**’anc2+93-sj胡说’** 输出:4 输入**’===’** 输出:3

1
2
3
4
5
6
7
8
str1 = input("请输入：")
count = 0
for i in str1:
    if 'a' <= i <= 'z' or 'A' <= i <= 'Z' or '0' <= i <= '9':
        continue
    else:
        count += 1
print("非数字字母的个数为：",count)

9. 输入字符串，将字符串的开头和结尾变成’+’，产生一个新的字符串

例如: 输入字符串**’abc123’, 输出‘+bc12+’**

1
2
3
str1 = input("请输入一个字符串：")
new_str1 = (str1[1:len(str1)-1]).center(len(str1),'+')
print("新的字符串为：",new_str1)

10. 输入字符串，获取字符串的中间字符

例如: 输入**’abc1234’** 输出:‘1’ 输入**’abc123’** 输出**’c1’**

1
2
3
4
5
a = input("请输入字符串:")
if len(a) % 2:
    print(a[len(a)//2])
else:
    print(a[len(a)//2-1],a[len(a)//2],sep='')

11. 写程序实现字符串函数find/index的功能(获取字符串1中字符串2第一次出现的位置)

例如: 字符串1为:how are you? Im fine, Thank you! , 字符串2为:you, 打印8

1
2
3
4
5
6
7
8
9
10
11
str1 = input("请输入字符串1：")
str2 = input("请输入字符串2：")
count = 0
if str2 in str1:
    for item in str1:
        count+=1
        if item == str2[0]:
            break
else:
    print("字符串2不在字符串1中")
print("字符串1中字符串2第一次出现的位置为：",count-1)

12. 获取两个字符串中公共的字符

例如: 字符串1为:abc123, 字符串2为: huak3 , 打印:公共字符有:a3

1
2
3
4
5
6
7
8
str1 = 'abca123'
str2 = 'huak3'
sum_str = ''
for i in str1:
    if i in str2:
        if i not in sum_str:
            sum_str+=i
print(sum_str)
python基础

字典的基本操作与集合

字典的增和改

1.字典[键] = 值

1.1如果键存在时修改键对应的值,不存在则添加键值对

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
cat = {'name':'加菲','age':3,'color':'白色'}


## 添加
cat['breed'] = '蓝猫'
print(cat)  ##{'name': '加菲', 'age': 3, 'color': '白色', 'breed': '蓝猫'}
## 修改
cat['age'] = 2
print(cat)  ##{'name': '加菲', 'age': 2, 'color': '白色', 'breed': '蓝猫'}

## 添加 setdefault 方法，如果存在的时候不会修改，没有才添加
cat.setdefault('weight',5)
print(cat)
## {'name': '加菲', 'age': 2, 'color': '白色', 'breed': '蓝猫', 'weight': 5}
cat.setdefault('age',4)
print(cat)
## {'name': '加菲', 'age': 2, 'color': '白色', 'breed': '蓝猫', 'weight': 5}

setdefault 方法实例

练习：在students中没有分数的学生中添加分数对应的键值对，分数值为零

1
2
3
4
5
6
7
8
9
10
11
students = [
    {'name': 'stu1', 'tel': '1234', 'score': 89},
    {'name': 'stu2', 'tel': '465', 'score': 80},
    {'name': 'stu3', 'tel': '678'},
    {'name': 'stu3', 'score': 78},
    {'name': 'stu4', 'tel': '234'}
]

for item in students:
    item.setdefault('score',0)
print(students)

字典的删除 - 删除键值对

1.1 del 方法 - del 字典[键]

1.1.1 如果不给键，会删除整个字典

1.1.2 删除指定键对应的键值对,键不存在会报错

1
2
3
4
5
6
cat = {'name':'加菲','age':3,'color':'白色'}
print(cat)
##{'name': '加菲', 'age': 3, 'color': '白色'}
del cat['color']
print(cat)
##{'name': '加菲', 'age': 3, 'color': '白色'}

1.2 pop 方法 - 字典.pop(键)

1.2.1 - 取出字典指定键对应的值

1.3.1 - 如果键不存在会报错

1
2
3
4
cat = {'name':'加菲','age':3,'color':'白色'}
del_value = cat.pop('color')
print(cat)
print(del_value)

字典的相关操作

1.1 字典不支持 +,*,也不支持比较大小的运算符，支持 == ,!=

1.2 in 或 not in 判断字典中是否存在指定键

1.3 键 in / not in 字典

1
2
3
dict1 = {'a':10,'b':20,'c':30}
print(10 in dict1)  ##False
print('a' in dict1)  ##True

1.4 相关函数

1.4.1 len 获取长度

1.4.2 dict(数据) -

1)数据本身是一个序列,

2)序列中的元素是有且只有两个元素的小序列

3)小序列的第一个元素是不可以改变的数据

1
2
3
4
5
6
7
8
9
data = [('a',10),('b',20)]
print(dict(data))
## {'a': 10, 'b': 20}

data2 = ['ab',range(2),[10,20]]
print(dict(data2))
## {'a': 'b', 0: 1, 10: 20}

## data2 = ['abc',range(2),[10,20]] ##报错

1.5 字典转换成列表和元组

1
2
3
4
5
dict2 = {'a':10,'b':20,'c':30}
print(list(dict2))  ##list 只拿到字典的键
## ['a', 'b', 'c']
print(tuple(dict2))  ##tuple 也只拿到字典的键
## ('a', 'b', 'c')

1.6 字典相关方法

1.6.1 clear - 清空

1)字典.clear()

1
2
3
dict2 = {'a':10,'b':20,'c':30}
dict2.clear()
print(dict2)

1.6.2 copy - 复制产生一个一样的新字典

1)字典.copy()

1
2
3
dict2 = {'a':10,'b':20,'c':30}
dict3 = dict2.copy()
print(dict3)

1.6.3 items，keys,values

1)字典.keys() - - 获取字典键

1
2
3
dict2 = {'a':10,'b':20,'c':30}
print(dict2.keys())
## dict_keys(['a', 'b', 'c'])

2)字典.values() - 获取字典值

1
2
3
dict2 = {'a':10,'b':20,'c':30}
print(dict2.values())
## dict_values([10, 20, 30])

3)字典.items() - 取出元素

1
2
3
dict2 = {'a':10,'b':20,'c':30}
print(dict2.items())
## dict_items([('a', 10), ('b', 20), ('c', 30)])

1.6.4 update

1)字典.update(序列)

2)将序列中的所有元素都添加到字典中(如果存在则覆盖)

3)序列必须是字典或者是能转换成字典的序列

1
2
3
4
5
6
7
8
9
10
11
12
13
dict2 = {'a':10,'b':20,'c':30}
dict3 = {'d':40}
print(dict2)
## {'a': 10, 'b': 20, 'c': 30}
dict2.update(dict3)
print(dict2)
## {'a': 10, 'b': 20, 'c': 30, 'd': 40}
dict2.update(['xy','mn'])
print(dict2)
## {'a': 10, 'b': 20, 'c': 30, 'd': 40, 'x': 'y', 'm': 'n'}
dict2.update({'d':50,'e':60})
print(dict2) ## 键'd'存在，值被修改,'e'被添加
## {'a': 10, 'b': 20, 'c': 30, 'd': 50, 'x': 'y', 'm': 'n', 'e': 60}

1.7 字典的推导式

1.7.1 {键的表达式:值的表达式 for 变量 in 序列}

练习1. 通过字典的推导式交换字典的键和值

1
2
3
dict1 = {'a':10,'b':20}
dict2 = {dict1[key]:key for key in dict1}
print(dict2)

1.7.2 {键的表达式:值的表达式 for 变量 in 序列 if 条件语句}

集合 - set

1 集合是容器型数据 - 将 {}作为容器的标志

1.1 多个元素用逗号隔开

1.2 集合是可变的，并且集合是无序的

1.3 集合的元素是不可变的数据，且是唯一的

2.1 空集合

1
2
3
set1 = set()
print(type(set1),set1,len(set1))
##<class 'set'> set() 0

2.2 集合无序

1
2
print({1,2,3}=={3,1,2})
## True

2.3 元素必须是不可变的数据

1
2
3
4
5
set2 = {1,'abc',(2,3)}
print(set2)
## {(2, 3), 1, 'abc'}

## set3 = {1,'abc',[2,3]}  ##报错

2.4 元素是唯一的

1
2
3
set4 = {1,2,3,2,4,1,5,4,1}
print(set4)
## {1, 2, 3, 4, 5}

3 集合元素的增删改查

3.1 查 - 遍历

1
2
for 元素 in 集合
    循环体
1
2
3
set1 = {23,90,80,92,77}
for x in set1:
    print(x)

3.2 增

3.2.1 集合.add(元素) 在集合中添加指定元素

1
2
3
4
set1 = {23,90,80,92,77}
set1.add(34)
print(set1)
## {34, 77, 80, 23, 90, 92}

3.2.2 集合.update(序列) - 将序列中的元素全部添加到集合中

1
2
3
4
set1 = {23,90,80,92,77}
set1.update('abc')
print(set1)
## {'b', 'a', 77, 80, 'c', 23, 90, 92}

3.3 删

3.3.1 集合.remove(元素)

删除指定元素，元素不存在会报错

1
2
3
4
set1 = {23,90,80,92,77}
set1.remove(77)
print(set1)
## set1.discard(1)  ## 报错，元素不存在

3.3.2 集合.discard(元素)

删除指定元素，元素不存在不会报错

1
2
3
4
5
set1 = {23,90,80,92,77}
set1.discard(90)
print(set1)

## set1.discard(1)  ## 不会报错

4 改 - 无法直接修改元素的值

4.1 方法1：将要修改的元素删除，添加需要的元素

将小写的a改成大写的A

1
2
3
4
set5 = {'a','b','c'}
set5.remove('a')
set5.add('A')
print(set5)

5 数学集合运算 : & (交集),|(并集),-(差集),^(对称差集),>/<(真子集),>=,<=(子集)

5.1 集合1 & 集合2 - 获取两集合的公共元素

1
2
3
4
set1 = {1,2,3,4,5,6,7}
set2 = {5,6,7,8,9,10,11}
print(set1 & set2)
## {5, 6, 7}

5.2 集合1 | 集合2 - 合并两个集合

1
2
3
4
set1 = {1,2,3,4,5,6,7}
set2 = {5,6,7,8,9,10,11}
print(set1 | set2)
## {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}

5.3 集合1 - 集合2 集合1减去集合1中包含在集合2的元素

1
2
3
4
5
6
set1 = {1,2,3,4,5,6,7}
set2 = {5,6,7,8,9,10,11}
print(set1 - set2)
## {1, 2, 3, 4}
print(set2 - set1)
## {8, 9, 10, 11}

5.4 集合1 ^ 集合2 将两个集合合并，去掉公共部分

1
2
3
set1 = {1,2,3,4,5,6,7}
set2 = {5,6,7,8,9,10,11}
print(set1 ^ set2)

5.5 集合1 >/< 集合2 -> 判断集合2是否是集合1的真子集/判断集合1是否是集合2的真子集

作业

1.定义一个列表，在列表中保存6个学生的信息(学生信息中包括: 姓名、年龄、成绩(单科)、电话、性别(男、女、不明) )

1
2
3
4
5
6
7
8
list1 = [
    {'姓名':'张三','age':18,'score':99,'tel':'1828','sex':'男'},
    {'姓名':'李四','age':20,'score':88,'tel':'1824','sex':'男'},
    {'姓名':'王五','age':21,'score':49,'tel':'1823','sex':'女'},
    {'姓名':'小花','age':18,'score':87,'tel':'1825','sex':'女'},
    {'姓名':'小明','age':23,'score':56,'tel':'1826','sex':'不明'},
    {'姓名':'小毛','age':25,'score':78,'tel':'1827','sex':'男'},
]

1. 1统计不及格学生的个数

1
2
3
4
5
count = 0
for item in list1:
    if item['score']<60:
        count+=1
print("不及格学生个数为：",count)

1. 2打印不及格学生的名字和对应的成绩

1
2
3
for item in list1:
    if item['score']<60:
        print(item['姓名'],item['score'])

1.3 打印手机尾号是8的学生的名字

1
2
3
for item in list1:
    if int(item['tel']) % 10 == 8:
        print(item['姓名'],item['tel'])

1.4 打印最高分和对应的学生的名字

1
2
3
4
5
6
7
max_score = 0
for item in list1:
    if item['score'] > max_score:
        max_score = item['score']
for i in list1:
    if i['score'] == max_score:
        print(i['姓名'],i['score'])

1.5 删除性别不明的所有学生

1
2
3
4
for item in list1:
    if item['sex'] == '不明':
        list1.remove(item)
print(list1)

1.6 将列表按学生成绩从大到小排序(挣扎一下，不行就放弃)

1
2
3
4
5
6
7
8
9
10
11
for x in range(len(list1)):
    i = 0
    j = 1
    while j<len(list1):
        if list1[i]['score'] < list1[j]['score']:
            k = list1[j]
            list1[j] = list1[i]
            list1[i] = k
        i+=1
        j+=1
print(list1)

2.用三个集合表示三门学科的选课学生姓名(一个学生可以同时选多门课)

1
2
3
chinese = {'小明', '小花', '张三', '王五','赵六'}
english = {'小翠', '李四', '张三', '王五','赵六'}
math = {'小明', '李四', '王五','赵六'}

2.1 求选课学生总共有多少人

1
print('选课总人数为：',len(chinese|english|math))

2.2 求只选了第一个学科的人的数量和对应的名字

1
2
3
4
5
6
7
count = 0
set1 = set()
for item in chinese:
    if item not in english and item not in math:
        count+=1
        set1.add(item)
print('只选了第一个学科的数量为：',count,'名字有：',set1)

2.3 求只选了一门学科的学生的数量和对应的名字

1
2
set2 = (chinese|english|math)-(chinese&english)-(chinese&math)-(english&math)
print("学生数量为：",len(set2),"名字有",set2)

2.4 求只选了两门学科的学生的数量和对应的名字

1
2
3
4
5
6
7
count =0
set3 = set()
for item in chinese:
    if (item in english and item not in math) or (item in math and item not in english):
        count+=1
        set3.add(item)
print('只选了两门学科的人数为：',count,'名字有：',set3)

2.5 求选了三门学生的学生的数量和对应的名字

1
2
3
4
5
6
7
count =0
set4 = set()
for item in chinese:
    if item in english and item in math:
        count+=1
        set4.add(item)
print("选了三门学生的数量为：",count,'名字有：',set4)