使用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))
推导式创建序列
- 列表推导式
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)
- 字典推导式
- 题目:统计文本中字符出现的次数:
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)
- 集合推导式
{x for x in range(1,5) if x%2==0}
- 生成器推导式(生成元组)
g=(x for x in range(4))
print(g)
#<generator object <genexpr> at 0x00000227833E04A0>
print(tuple(g))
#(0,1,2,3) g是生成器对象,生成器是可迭代对象,只能使用一次
print(tuple(g))
#()
绘制不同颜色的多个同心圆
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() #程序执行完,窗口仍在
- 操作:画一个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.函数是代码复用的通用机制
- 函数分类
- 函数的定义和调用
def test01():
print("*"*10)
test01()
print(type(test01))
#function:对象
形参和实参、返回值
- 形参与实参和java相同
- 文档字符串(函数的注释)
- 通过三个单引号或者三个双引号来实现,中间可以加入多行文字进行说明
- 调用help(函数名.doc)可以打印输出函数的文档字符串
def print_start(n):
'''打印*号'''
print(("*")*n)
print_start(9)
help(print_start.__doc__)
#*********
#No Python documentation found for '打印*号'.
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))
对象的基本组成和内存示意图
- 对象
a=3
print(id(a))
print(type(a))
print(type(3))
- 引用的本质
放对象的为堆
放变量的为栈
函数也是对象
#测试函数也是对象
def test0():
print("sxt")
test01() #sxt
c=test01
c() #sxt
print(id(test01))
print(id(c))
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
- 局部变量和全局变量效率问题
#测试局部、全局效率
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.对“不可变对象”进行“写操作”,会产生一个新的“对象空间”,并用新的值填充这块空间
可变对象:字典、列表、集合、自定义的对象等
不可变对象:数字、字符串、元组、function等
- 传递可变对象的引用
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】
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))
- 不可变对象含可变对象
#传递不可变对象,如果发生拷贝,是浅拷贝
#不可变对象包含的子对象是可变的,则方法内修改了这个可变对象,源对象也发生改变
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.位置参数:按位置传递的参数
def f1(a,b):
print(a,b)
f1(8,9)
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
3.命名参数:按照形参的名称传递参数
def f1(a,b.c)
print(a,b,c)
f1(c=10,a=20,b=30) #a=20,b=30,c=10
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)
5.强制命名参数
在带星号的"可变参数"后面增加新的参数,必须在调用时"强转命名参数"
def f1(*a,b,c):
print(a,b,c)
f1(3,b=3,c=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)