拷贝、函数

###一、浅拷贝和深拷贝

####1、拷贝：将变量中的值复制一份，产生新的数据，然后将新的数据对应的地址返回

#####a、copy.copy(对象):浅拷贝：直接拷贝地址(切片和字典列表的copy方法都是浅拷贝)

#####b、copy.deepcopy(对象)：深拷贝：将地址对应值拷贝，产生新的地址

###二、字典和列表的应用
列表的元素和字典的值可以是任何类型的元素

####1、列表中有字典

1
2
3
4
5
6
7
persons = [
    {'name': '张三', 'age': 30, 'sex': '男'},
    {'name': '李四', 'age': 28, 'sex': '女'},
    {'name': '王五', 'age': 40, 'sex': '男'},
]
print(persons)
print(persons[1]['name'])

#####a练习：找出persons中年龄最大的人的名字

1
2
3
4
5
6
7
8
9
max = 0
name=''
for index in persons:
    age = index['age']
    if age > max1:
        max1 = age
        name = index['name']
print(name, max1)
输出的结果为：王五 40

####2.字典中有列表
练习：写一个程序，保存一个班级的信息，包含班级名，位置，所有学生(学生中需要保存名字，年龄和学校)

1
2
3
4
5
6
7
8
9
my_class = {
    'class_name': 'python1807',
    'location':  '18-600',
    'all_students': [
        {'name': '小花', 'age': 18, 'school': '清华'},
        {'name': '小红', 'age': 20, 'school': '北京'},
        {'name': '小明', 'age': 28, 'school': '川大'}
    ]
}

###三、函数的声明

####1、什么是函数？
函数：函数就是对实现某一特定功能的代码段的封装
分类：自定义函数(程序员自己声明实现其功能)和内置函数(系统已经声明实现完成)

####2、声明函数的语法
def 函数名(参数列表):
函数体
说明：
a.def —> python中声明函数的关键字
b.函数名 –> 标识符，不能是关键字。遵守PEP8命名规范(所有字母小写，多个单词之间使用下划线隔开)
c.() —> 固定格式
d.参数列表 —> 形参列表，参数名1，参数名2，…
可以有多个参数，也可以没有。参数是用来从函数的外部给函数里面传值用的

e.: —> 固定格式
f.函数体 —> 实现函数功能的代码段

####2.初学者怎么声明函数的步骤
a.确定函数的功能
b.根据功能确定函数名
c.确定参数：确定有没有参数，确定有几个(看实现函数功能需不需要从函数外面传值，需要传几个)
d.实现函数功能
e.确定返回值

####3.函数调用
声明函数的时候，不会执行函数体，函数体只有在函数调用的时候才会执行
语法：
函数名(实参列表)
说明：
函数名 —>必须是已经声明过的函数
() —>固定的写法
实参列表 —> 数据1，数据2，…(用来给形参赋值)

1
2
3
4
5
# 写一个函数，打印两个数的和
def yt_sum(num1, num2):
    print(num1 + num2)
yt_sum(10, 20)
输出的值为：30

###四、函数的调用

####1、函数调用格式
函数名(实参列表)

####2.函数的调用过程
第一步：回到函数声明的位置
第二步：用实参给形参(传参：一定要保证每个参数都有值)
第三步：执行函数体
第四步：返回返回值
第五步：执行完函数体就回到函数调用的位置，接着执行后面的代码

###五、函数的参数

####1、位置参数和关键字参数
位置参数：按照实参的顺序一一给形参赋值
关键字参数：形参1=值1，形参2=值2，…

1
2
3
4
5
6
def func1(a, b, c):
    print('a:', a, 'b:', b, 'c:', c)
# 位置参数
func1(10, 20, 30)   # a: 10 b: 20 c: 30
# 关键字参数
func1(c=300, a=100, b=200)    # a: 100 b: 200 c: 300

####2、默认函数
函数声明的时候可以给参数设置默认值，但是，有默认值的参数，必须放在参数列表的最后，有默认值的参数，在调用的时候可以不用传参

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

####3、不定长参数
参数的个数不确定的时候，可以在形参前面加*，将形参变成一个元组，用来接收多个参数
注意：如果函数有多个参数，n那么不定长参数要放在最后

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 写一个函数，计算多个数的和
def my_sum(*nums):
    print(sum(nums))

my_sum()
my_sum(1)
my_sum(1, 2, 3)
0
1
6

def func4(name, age, *score):
    print(name, age, score)
func4('小花', 18, 90, 80, 88)
# 小花 18 (90, 80, 88)

###六、函数的调用
1、函数的返回值就是调用表达式的值，就是return关键字后面表达式的值
2、python中所有的函数都有返回值，返回值默认是None(执行函数体没有遇到return，函数的返回值就是None，遇到了return函数的返回值是return后面的值)
3、函数调用表达式 –>调用函数的语句(函数名(实参))
4、return –>关键字，只能写在函数体中，用来返回返回值和结束语句

######注意：看一个函数的返回值，只看有没有遇到return。只要没有遇到就是return,遇到return就是return后面的值

作业

1. 编写一个函数，求1+2+3+…+N

1
2
3
4
5
6
7
8
def sum1(N):
    sum2 = 0
    for x in range(1, N+1):
        N += 1
        sum2 +=x
    print(sum2)
sum1(20)
# 210

2. 编写一个函数，求多个数中的最大值

1
2
3
4
5
6
7
8
9
10
def max1(*number):
    max2 = number[0]
    for x in number:
        if max2 > x:
           break
        else:
            max2 = x
    print('max:', max2)
max1(10, 20, 50, 80)
#  max: 80

3. 编写一个函数，实现摇骰子的功能，打印n个骰子的点数和

1
2
3
4
5
6
7
8
9
import random
def sum3(n):
    sum4 = 0
    for index in range(0, n):
        x = random.randint(1, 7)
        sum4 += x
    print('骰子的点数和为：', sum4)
sum3(6)
#  骰子的点数和为： 23

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

如:{‘a’:1, ‘b’:2, ‘c’:3} —> {1:’a’, 2:’b’, 3:’c’}

1
2
3
4
5
6
7
8
9
10
11
12
def exchange1(dict1):
    for key in dict1.copy():
        # 通过key拿到值
        value = dict1[key]
        # 删除原来的键值对
        del dict1[key]
        # 将值作为key，键作为value，添加键值对
        dict1[value] = key
dict2 = {'a':1, 'b':2, 'c':3}
exchange1(dict2)
print(dict2)
# 交换后的字典为: {1: 'a', 2: 'b', 3: 'c'}

5. 编写一个函数，提取指定字符串中的所有的字母，然后拼接在一起后打印出来

如:’12a&bc12d–’ —> 打印’abcd’

1
2
3
4
5
6
7
8
9
def zi_mu(str1):
    str2 = ''
    for index in str1:
        if index.isalpha():
        # if 'a' <= index <= 'z' or 'A' < index < 'Z':
            str2 += index
    print(str2)
zi_mu('12a&bc12d--')
# abcd

6. 写一个函数，求多个数的平均值

1
2
3
4
5
6
7
8
9
10
def average(*number):
    sum1 = 0
    n = 0
    for x in number:
        sum1 += x
        n += 1
        ave1 = (sum1/n)
    print(ave1)
average(1,2,3,4,5,6,7,8,9)
# 5.0

7. 写一个函数，默认求10的阶层，也可以求其他数的阶层

1
2
3
4
5
6
7
def jie_ceng(n=10):
    sum1 = 1
    for x in range(1, n+1):
        sum1 *= x
    print(sum1)
jie_ceng()
#  362880

8. 写一个函数，可以对多个数进行不同的运算

如: operation(‘+’, 1, 2, 3) —> 求 1+2+3的结果 operation(‘-‘, 10, 9) —> 求 10-9的结果 operation(‘‘, 2, 4, 8, 10) —> 求 24810的结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def operation(fu_hao, *n):
    if fu_hao == '+':
        sum1 = 0
        for x in n:
            sum1 += x
        print(sum1)
    if fu_hao == '-':
        sum2 = n[0]
        for x in range(1, len(n)):
            sum2 -= n[x]
        print(sum2)
    if fu_hao == '*':
        sum3 = 1
        for x in n:
            sum3 *= x
        print(sum3)
operation('+', 1, 2, 3)   #  6
operation('-', 10, 9) #  1

9.写一个函数，求指定列表中，指定的元素的个数

1
2
3
4
5
6
7
8
def num1(list1,n):
    x = 0
    for i in list1:
        if i == n:
            x += 1
    return x
print(num1([1,2,3,4,5,4,3,4,3,4],3))
# 3

10.写一个函数，获取指定列表中指定元素对应的下标(如果有多个，一起返回)

1
2
3
4
5
6
7
8
def index(list1,n):
    list2 = []
    for i in range(len(list1)):
        if n == list1[i]:
            list2.append(i)
    return list2
print(index([1,2,3,4,5,2,3,2,3,5],3))
# [2, 6, 8]