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

import turtle
t = turtle.Pen()
my_colors=('red','green','pink','black')
t.speed(10)

for i in range(10):
    t.penup()
    t.goto(0,-i*10)
    t.pendown()
    t.color(my_colors[i%len(my_colors)])
    t.circle(15+i*10)

turtle.done()

推导式创建序列

列表推导式

[表达式 for item in 可迭代对象 if 条件判断]

[x*2 for x in range(1,20) if x%5==0]

cells = [(row,col) for row in range(1,10) for col in range(1,10)] #可以使用两个循环

字典推导式

{key : value for 表达式 in 可迭代对象}

my_text ='i love you, i love he, i love 123'

char_count ={c:my_text.count(c) for c in my_text}

集合推导式

{key for 表达式 in 可迭代对象}

b={x for x in range(1,100) if x%9 ==0}

生成器推导式(生成元组)

一个生成器只能运行一次

使用zip()并行迭代

zip()对多个序列进行并行迭代

循环代码优化

1. 尽量减少循环内部不必要的计算

2. 嵌套循环中，尽量减少内层循环的计算，尽可能向外提。

3. 局部变量查询较快，尽量使用局部变量。

其他优化手段:

1. 连接多个字符串，使用join()而不使用+

2. 列表进行元素插入和删除，尽量在列表尾部操作

else语句

如果没被break中断，则会执行else

while 条件表达式:

    循环体

else:

    语句块

break语句

break跳出最近一层的循环

continue语句

continue语句用于结束本次循环，继续下一次。应用于最近的一层循环

打印九九乘法表

for m in range(1,10):
    for n in range(1,m+1):
        print('{0}*{1}={2}'.format(m,n,(m*n)),end='\t')
    print()

嵌套循环

一个循环体里可以嵌入另外一个循环，一般称为‘嵌套循环’。

for x in range(5):

    for y in range(5):

        print(x,end='\t')

    print() #起到换行的作用

for循环和可迭代对象

for 变量 in 可迭代对象:

    循环体语句

可迭代对象

1. 序列。包括：字符串、列表、元组

2. 字典

3. 迭代器对象（iterator）。range对象

sum_all = 0

for x in range(101):

    sum_all += x

print(sum_all)

4. 生成器对象

循环结构

如果符合条件，反复执行循环体的语句。

while循环

while 条件表达式:

    循环体语句

选择结构嵌套

使用时注意控制好不同级别的缩进量，缩进量决定了代码的从属关系。

多分支选择结构

if 表达式1:

    语句1

elif 表达式2:

    语句2

……

else:

    语句n

双分支

if 条件表达式：

    语句1

else:

    语句2

三元条件运算符

简单双分支赋值情况

条件为真时的值 if (条件表达式) else 条件为假时的值

print('s<10' if 5<10 else 's>=10')

选择结构

选择结构：单分支、双分支、多分支。

单分支

if 条件表达式:

    语句

num=input('请输入一个数字:')

if int(num)>10:

    print(num)

条件表达式详解

False、空序列、空值、0、空迭代对象

其他均为True

条件表达式不能出现=，==表示等于判断

控制语句

数据可以看做是‘砖块’。控制语句是代码的组织方式，可以看做是‘混凝土’。

集合

集合无序可变，元素不能重复。实际上，集合底层是字典实现，只有字典的‘键对象’。因此是不能重复且唯一的。

集合创建和删除

1. 使用{}创建，并使用add()方法添加元素

a={3,5,7}

a.add(9)

print(a)

2. 使用set()，将元组、列表等可迭代对象转成集合

3.remove()删除指定元素，clear()清空整个集合

集合相关操作

a|b #并集

a.union(b)

a&b #交集

a.intersection(b)

a-b #差集

a.difference(b)

根据键查找‘键值对’的底层过程

a.get('name')

第一步，我们计算'name'对象的散列值：

bin(hash('name'))

和存储的底层流程算法一致。取散列值不同位置的数字，然后查看偏移量对应的bucket是否为空。如果为空，返回None。如果不为空，则将这个bucket的键对象计算对应散列值，和我们的散列值进行比较。相等则返回对应'值对象'。不相等，则重新计算偏移量。依次取完后仍然没找到，则返回None。

字典核心底层原理（重要）

字典对象的核心是散列表。散列表是一个稀疏数组（总有空白元素的数组）。数组的每个单元叫做bucket。每个bucket有两部分：一个是键对象的引用，一个是值对象的引用。通过偏移量来读取指定bucket。

将一个键值对放进字典的底层过程

第一步计算key的散列值。Python中可以通过hash()来计算。

拿出计算出的散列值的最后面3位数‘101’作为偏移量，十进制是数字5。我们查看偏移量5对应的bucket是否为空。则把键值对放进去。如果不为空，则依次取后面3位作为偏移量，直到找到为空的bucket将键值对放进去。

复杂表格数据存储

表格数据使用字典和列表存储，并实现访问。

r1={'name':'ben','age':18,'city':'BJ'}

r2={'name':'joe','age':19,'city':'SH'}

r3={'name':'cici','age':20,'city':'SZ'}

tb=[r1,r2,r3]

#获得第二行人的城市

print(tb[1].get('city'))

#打印所有的薪资

for i in range(len(tb)):

    print(tb[i].get('city'))

#打印表的所有数据

for i in range(len(tb)):

print(tb[i].get('name'),tb[i].get('age'),tb[i].get('city'))

序列解包

序列解包可以用于元祖、列表、字典，对多个变量赋值。

x,y,z=(20,30,10)

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

[a,b,c]=(20,30,10)

字典序列解包

s={'name':'ben','age':18,'sex':'man'}

a,b,c=s #接收键

e,d,f=s.values() #接收值

h,i,j=s.items() #接收键值对