Python4

使用zip进行迭代

我们可以通过zip()函数对多个序列进行并行迭代，zip()函数在最短序列“用完”时就会停止

names=["gg","hh","jj"]
ages=[17,18,19]
citys=["beijing","dd"]

for name,age,city in zip(names,ages,citys):
    print("{0}--{1}--{2}".format(name,age,city))
1
2
3
4
5
6

关于print

推导式创建序列

• 列表推导式

a=[x for x in range(1,5)]
print(a)
a=[x*2 for x in range(1,5) if x%5!=0]
print(a)
cells=[(row,col) for row in range(1,10) for col in range(1,10)]
print(cells)
1
2
3
4
5
6

• 字典推导式
  
• 题目：统计文本中字符出现的次数：

my__test="i love you ,i love sxt,i love gaoqi"
char_count={c:my__test.count(c) for c in my__test}
print(char_count)
1
2
3

• 集合推导式
  

{x for x in range(1,5) if x%2==0}
1

• 生成器推导式（生成元组）
  

g=(x for x in range(4))
print(g)
# at 0x00000227833E04A0>
print(tuple(g))
#(0,1,2,3) g是生成器对象，生成器是可迭代对象，只能使用一次
print(tuple(g))
#()
1
2
3
4
5
6
7

绘制不同颜色的多个同心圆

import  turtle

my_color=("red","green","yellow","blue")
t=turtle.Pen()
t.width(4)
t.speed(6)
for i in range(10):
    t.penup()
    t.goto(0,-i*10)
    t.pendown()
    t.color(my_color[i%4])
    t.circle(15+i*10)


turtle.done() #程序执行完，窗口仍在
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 操作：画一个18*18的棋盘

import  turtle

t=turtle.Pen()
t.goto(180,0)
t.goto(180,-180)
t.goto(0,-180)
t.goto(0,0)

for x in range(18):
    t.penup()
    t.goto(0,-(10+x*10))
    t.pendown()
    t.goto(180,-(10+x*10))

t.penup()
t.goto(0,0)
for x in range(18):
    t.penup()
    t.goto(10+10*x,0)
    t.pendown()
    t.goto(10+10*x,-180)

turtle.done()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

函数的基本概念

• 基本概念

1.一个程序由一个任务组成：函数就是代表一个任务或者一个功能
2.函数是代码复用的通用机制

• 函数分类

• 函数的定义和调用
  
  

def test01():
    print("*"*10)

test01()
print(type(test01))
#function：对象
1
2
3
4
5
6

形参和实参、返回值

• 形参与实参和java相同
• 文档字符串（函数的注释）

• 通过三个单引号或者三个双引号来实现，中间可以加入多行文字进行说明
• 调用help(函数名.doc)可以打印输出函数的文档字符串

def print_start(n):
    '''打印*号'''
    print(("*")*n)

print_start(9)
help(print_start.__doc__)
#*********
#No Python documentation found for '打印*号'.
1
2
3
4
5
6
7
8

return返回值要点：

• 如果函数体中包含return语句，则结束函数并执行返回值
• 如果函数体中不包含return语句，则返回None值
• 要返回多个返回值，使用列表、元组、字典、集合将多个值“存起来”即可

def add(a,b):
    print("计算两个数的和:{0},{1},{2}".format(a,b,(a+b)))
    return a+b

print(add(3,7))

def test02():
    print("sxt")
    print("gao")
    return  #return两个作用：1.返回值 2.结束函数的执行
    print("hello")

test02()
print(test02()) #None

def test03(x,y,z):
    return [x*10,y*10,z*10] #返回列表

print(test03(1,2,3))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

对象的基本组成和内存示意图

• 对象

a=3
print(id(a))
print(type(a))
print(type(3))
1
2
3
4

• 引用的本质

放对象的为堆
放变量的为栈

函数也是对象

#测试函数也是对象
def test0():
	print("sxt")

test01() #sxt
c=test01
c() #sxt

print(id(test01))
print(id(c))
1
2
3
4
5
6
7
8
9
10

1.堆创建了一个tset01的对象，栈保存了一个名为test01的变量（地址）
2.把tset01的值拷贝给c

变量的作用域

• 全局变量

• 1.在函数和类定义之外声明的变量。作用域为定义的模板。从定义位置到模板结束

• 2. 函数内要改变全局变量的值，使用global声明一下

• 局部变量

• 1.在函数体中声明的变量

  2.如果局部变量和全局变量同名，使用局部变量

栈帧 stack frame：执行完之后就丢掉，局部变量在这里面

a=100
print(a) #a=100
def test01():
	b=4
	print(b*10)
	global a #全局变量的a
	a=300
	print(locals()) #打印局部变量
	print(globals()) #打印全局变量
print(a) #a=300
1
2
3
4
5
6
7
8
9
10

• 局部变量和全局变量效率问题

#测试局部、全局效率
import  math
import time
def test01():
    start =time.time()
    for i in range(10000000):
        math.sqrt(30)
    end=time.time()
    print("耗时{0}".format((end-start)))

def test02():
    b=math.sqrt
    start=time.time()
    for i in range(10000000):
        b(30)
    end=time.time()
    print("耗时{0}".format((end-start)))

test01()
test02()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

参数

• 参数的传递

具体分为两类：
1.对“可变对象”进行“写操作”，直接作用于源对象本身
2.对“不可变对象”进行“写操作”，会产生一个新的“对象空间”，并用新的值填充这块空间

可变对象：字典、列表、集合、自定义的对象等
不可变对象：数字、字符串、元组、function等

1. 传递可变对象的引用

b=[10,20]
def f2(m):
    print("m",id(m)) #b和m是同一个对象
    m.append(30)   #由于m是可变对象，不创建对象拷贝，直接修改这个对象

f2(b)
print("b",id(b))
print(b)  #【10，20，30】
1
2
3
4
5
6
7
8

2.传递不可变对象的引用

a=100
def f1(n):
    print("n",id(n))  #传递进来是a对象的地址
    n=n+200  #由于a不可变，因此创建新对象n
    print("n",id(n))
    print(n)  #n已经变成新对象

f1(a)
print("a",id(a))
1
2
3
4
5
6
7
8
9

• 不可变对象含可变对象

#传递不可变对象,如果发生拷贝，是浅拷贝
#不可变对象包含的子对象是可变的，则方法内修改了这个可变对象，源对象也发生改变
a=(10,20,[5,6])
print("a:",a)

def test01(m):
    print("m:",id(m))
    m[2][0]=888
    print(m)
    print("m:",id(m))

test01(a)
print("a:",id(a))
1
2
3
4
5
6
7
8
9
10
11
12
13

• 参数类型

1.位置参数：按位置传递的参数

def f1(a,b):
	print(a,b)
f1(8,9)
1
2
3

2.默认值参数放在位置参数后面

def f1(a,b,c=10,d=20):
	print(a,b,c,d)

f1(8,9)
f1(8,9,19) #c=19
f1(8,9,19,29) #c=19,d=29
1
2
3
4
5
6

3.命名参数：按照形参的名称传递参数

def f1(a,b.c)
	print(a,b,c)

f1(c=10,a=20,b=30) #a=20,b=30,c=10
1
2
3
4

4.可变参数：可变数量的参数

1.*（一个星号），将多个参数收集到一个"元组"对象中
2.**（两个星号），将多个参数收集到一个"字典"对象中

def f1(a,b,*c):
    print(a,b,c)
f1(8,9,19,20)

def f2(a,b,**c):
    print(a,b,c)
f2(8,9,name='gaoqi',age=17)

def f3(a,b,*c,**d):
    print(a,b,c,d)
f3(8,9,20,30,name="gaoqi",age=19)
1
2
3
4
5
6
7
8
9
10
11

5.强制命名参数

在带星号的"可变参数"后面增加新的参数，必须在调用时"强转命名参数"

def f1(*a,b,c):
    print(a,b,c)

f1(3,b=3,c=4)
1
2
3
4

浅拷贝和深拷贝

浅拷贝(copy)：不拷贝子对象的内容，只是拷贝子对象的引用
深拷贝(deepcopy)：会连子对象的内存全部拷贝一份，对子对象的修改不会影响源对象

import copy

a=[10,20,[5,6]]
b=copy.copy(a)

print("a:",a)
print("b:",b)

b.append(30)
b[2].append(7)

print("浅拷贝...")
print("a:",a)
print("b:",b)

print("----------")
a=[10,20,[5,6]]
b=copy.deepcopy(a)
print("a:",a)
print("b:",b)

b.append(30)
b[2].append(7)

print("深拷贝...")
print("a:",a)
print("b:",b)
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