推导式
a = [i for i in range(1,1001) if i % 3 == 0 and i % 7 == 0 and i % 13 == 0]
print(a) #[273, 546, 819]
def pingfang(a):
return a * a
b = [pingfang(i) for i in range(5) if i % 2 == 0]
print(b) #[0, 4, 16]
b = [i*i for i in range(5) if i % 2 == 0]
print(b) #[0, 4, 16]
a = [1,2,3,4,5]
b = [a[i] * 2 for i in range(len(a)) if i % 2 == 0]
print(b) #[2, 6, 10]
c = [a[i] * 2 for i in range(len(a)) if a[i] % 2 == 0]
print(c) #[4, 8]
a = [[1,2,3],[4,5,6],[7,8,9]]
b = [a[0][i] for i in range(len(a))]
print(b) #[1, 2, 3]
b = [a[i][i] for i in range(len(a))]
print(b) #[1, 5, 9]
b = [a[i][0] for i in range(len(a))]
print(b) #[1, 4, 7]
b = [a[i][2-i] for i in range(len(a))]
print(b) #[3, 5, 7]
b = [a[i][i] for i in range(len(a)-1,-1,-1)]
print(b) #[9, 5, 1]
a = [[1,2,3],[4,5,6,7],[8,9,10,11,12]]
for i in range(len(a)):
for j in range(len(a[i])):
print(a[i][j],end = " ") #1 2 3 4 5 6 7 8 9 10 11 12
b = [a[i][j] for i in range(len(a)) for j in range(len(a[i]))]
print(b) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
c = [y for x in a for y in x]
print(c) #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
字典推导式
a = {1:2,3:4,5:6}
b = {v:k for k,v in a.items()}
print(b) #{2: 1, 4: 3, 6: 5}
a = {k:v for k,v in zip(["a","b","c"],(1,2,3))}
print(a) #{'a': 1, 'b': 2, 'c': 3}
b = zip(["a","b","c"],(1,2,3))
print(b) #<zip object at 0x0000000003A04388>
for x in b:
print(x,end = "") #('a', 1)('b', 2)('c', 3)
a = {"a":1,"A":2,"b":3,"B":4,"c":5}
print(a.get("a",0)) #1
print(a.get("a".upper(),0)) #2
print(a.get("B".lower(),0)) #3
print(a.get("c".upper(),0)) #0
a = {"a":1,"A":2,"b":3,"B":4,"c":5,"D":6}
b = ["a","b","c"]
c = {k.lower():a.get(k.lower(),0) + a.get(k.upper(),0) for k in a.keys() if k in b}
print(c) #{'a': 3, 'b': 7, 'c': 5}
a = [1,2,3,1,2,3]
b = {i * i for i in a}
print(b) #{1, 4, 9}
模块
Python 模块(Module)，是一个 Python 文件，以 .py 结尾，包含了 Python 对象定义和Python语句。
模块让你能够有逻辑地组织你的 Python 代码段。
把相关的代码分配到一个模块里能让你的代码更好用，更易懂。
模块能定义函数，类和变量，模块里也能包含可执行的代码。
模块的导入方式
import + 模块
import one1_module
one1_module.hanshu1() #one1_module.hanshu1() = haha
import + 模块，模块，模块…
import one1_module,one2_module
one1_module.hanshu1() #one1_module.hanshu1() = haha
one2_module.hanshu1() #one2_module.hanshu1() = 哈哈哈
import + 模块 + as + 模块的简称:
import one1_module as t
t.hanshu1() #one1_module.hanshu1() = haha
from 语句让你从模块中导入一个指定的部分到当前命名空间中
from + 模块 + import + 函数、变量、类等
from one1_module import hanshu1,hanshu2,a,b
hanshu1() #one1_module.hanshu1() = haha
hanshu2() #one1_module.hanshu2() = hehe
print(a) #100
print(b) #200
from + 模块名 + import + 函数名 + as + 别称
from one1_module import hanshu1 as haha
haha() #one1_module.hanshu1() = haha
**from + 模块名 + import + ***
把一个模块的所有内容全都导入到当前的命名空间，但是对于 _下划线 开头的函数或变量不起作用
from one1_module import *
hanshu1() #one1_module.hanshu1() = haha
hanshu2() #one1_module.hanshu2() = hehe
print(a) #100
print(b) #200
print(_c) #NameError: name '_c' is not defined
from one2_module import * #导入的模块中，必须对函数做如下处理，才能被*号导入，__all__=[函数名,函数名，函数名...]
hanshu1() #one2_module.hanshu1() = 哈哈哈
hanshu2() #one2_module.hanshu2() = 嘿嘿嘿
hanshu3() #one2_module.hanshu3() = 呵呵呵
包
包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。
比如一个模块的名称是 A.B， 那么他表示一个包 A中的子模块 B 。
就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采用点模块名称这种形式也不用担心不同库之间的模块重名的情况。
在导入一个包的时候，Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
目录只有包含一个叫做 init.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）不小心的影响搜索路径中的有效模块。
最简单的情况，放一个空的 :file:init.py就可以了。当然这个文件中也可以包含一些初始化代码或者为（将在后面介绍的） __all__变量赋值。
用户可以每次只导入一个包里面的特定模块
导入包的几种方式：
import sys
a = sys.path
a.append('D:\\python第一阶段\\bao1')
import bao1.bao11.bao111.hehe
bao1.bao11.bao111.hehe.hehe() #我在hehe里
from bao1.bao11.bao111 import hehe
hehe.hehe() #我在hehe里
from bao1.bao11.bao111.hehe import hehe
hehe() #我在hehe里
from bao1.bao11.bao111 import *
heihei() #嘿嘿
hehe.hehe() #我在hehe里
haha.haha() #我在haha里
random随机数模块
random.random() #默认用于生成一个0到1的随机浮点数：0<= n < 1.0
random.randint(a, b) #用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数 n: a <= n <= b
random.uniform(a,b) #用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成的随机数n: a <= n <= b。如果 a <b， 则 b <= n <= a。
random.randrange([start], stop[, step]) #从指定范围内，按指定基数递增的集合中 获取一个随机数。
import random
a = random.randint(1,20) #1-20随机整数
print(a)
b = random.random() #0-1之间的随机浮点
print(b)
c = random.uniform(2.2,3.3) #指定范围内的浮点数
print(c)
d = random.randrange(1,23,3) #指定范围内，步长为3的数的随机整数
print(d)
random.choice(sequence) #从序列中获取一个随机元素
random.shuffle(x[, random]) #用于将一个列表中的元素打乱,即将列表内的元素随机排列。
import random
a = [1,2,3,4,5]
b = random.choice(a) #在列表a里随机选择一个
print(b)
random.shuffle(a) #打乱列表a，随机排列
print(a)
str.join(sequence)
将序列中的元素以指定的字符连接生成一个新的字符串。
a = "123"
b = "-".join(a) #以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
print(b) #1-2-3
定义一个函数，使用随机函数，随机生成一个 由数字和大写字母组成的 长度为4的 字符串
import random
def dev_code():
code = ""
for i in range(4):
a = random.randint(1,9)
b = chr(random.randint(65,90))
c = random.choice([a,b])
code = "".join([code,str(c)])
return code
x = dev_code()
print(x)
sys 模块
sys模块负责程序与python解释器的交互，提供了一系列的函数和变量，
用于操控python运行时的环境。
sys.argv
接收命令行参数，生成一个List，第一个元素是程序本身路径
sys.path
返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
import sys
print(sys.path) #['D:\\python第一阶段', 'D:\\python第一阶段', 'D:\\ProgramData\\Anaconda3\\python37.zip', 'D:\\ProgramData\\Anaconda3\\DLLs', 'D:\\ProgramData\\Anaconda3\\lib', 'D:\\ProgramData\\Anaconda3', 'D:\\ProgramData\\Anaconda3\\lib\\site-packages', 'D:\\ProgramData\\Anaconda3\\lib\\site-packages\\win32', 'D:\\ProgramData\\Anaconda3\\lib\\site-packages\\win32\\lib', 'D:\\ProgramData\\Anaconda3\\lib\\site-packages\\Pythonwin', 'D:\\Program Files\\JetBrains\\PyCharm 2017.3.4\\helpers\\pycharm_matplotlib_backend']
sys.path.append("D:\\python第一阶段\\bao1")
import bp #模块 bp
time模块
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
time.sleep(secs)
推迟调用线程的运行，secs指秒数。
import time
print("你好")
time.sleep(1)
print("你好")
time.time( )
返回当前时间的时间戳（1970纪元后经过的浮点秒数）。
import time
a = time.time()
print(a)
time.localtime([secs]
接收时间戳（1970纪元后经过的浮点秒数）并返回当地时间下的时间元组t（t.tm_isdst可取0或1，取决于当地当时是不是夏令时）。
import time
print(time.localtime())
time.strftime(fmt[,tupletime])
接受时间元组，格式化输出时间
import time
a = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
print(a)
time.strptime()
接受时间戳转化为时间元组
import time
a = "2019-4-30 17:02:30"
b = time.strptime("2019-4-30 17:02:30","%Y-%m-%d %H:%M:%S")
print(b)
time.mktime()
接受时间元组转化为时间戳
import time
a = time.localtime()
b = time.mktime(a)
print(a)
print(b)
time.ctime([secs])
作用相当于asctime(localtime(secs))，未给参数相当于asctime()
import time
print(time.asctime()) #Tue Apr 30 17:06:56 2019
print(time.ctime()) #Tue Apr 30 17:06:56 2019
import time
while True:
d = "2019-4-29 17:07:00"
dy = time.strptime("2019-4-29 17:07:00","%Y-%m-%d %H:%M:%S")
dc = int(time.mktime(dy))
xc = int(time.time())
zc = 7 * 24 * 60 * 60
sc = zc - xc + dc
day = sc // (24 * 60 * 60)
hour = sc % (24 * 60 * 60) // (60 * 60)
min = sc % (60 * 60) // 60
sec = sc % 60
print("剩余{}天{}时{}分{}秒解冻".format(day,hour,min,sec))
time.sleep(1)
作业
列表推导式
1.创建一个函数，输入一个大于1的整数，返回一个列表，
包含所有能够整除该整数的因子（不包含1和它本身），并且从小到大排序。
如果这个数是素数，则返回“(integer) is prime”。
def divisors1(integer):
list = []
for i in range(2,integer):
if integer % i == 0:
list.append(i)
if len(list) != 0:
return list
else:
return "%d is prime"%integer
print(divisors1(12)) #[2, 3, 4, 6]
print(divisors1(25)) #[5]
print(divisors1(13)) #13 is prime
def divisors2(integer):
a = [i for i in range(2,integer) if integer % i == 0]
return a if a else "%d is prime" % integer
print(divisors2(12)) #[2, 3, 4, 6]
print(divisors2(25)) #[5]
print(divisors2(13)) #13 is prime
2.使用列表推导式将一个二维列表转换成一个一维列表。
lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
转换成:lst2=[1, 2, 3, 4, 5, 6, 7, 8, 9]
使用列表推导式
lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
lst2 = [y for i in lst for y in i]
print(lst2)
3.现在有一列表lst = [[1,2,3],[4,5,6],[7,8,9]]
要求使用列表推导式取出 1、4、7 和 1、5、9 元素，思考如何取出
列表推导式
lst = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
a = [lst[i][0] for i in range(len(lst))]
print(a) #[1, 4, 7]
b = [lst[i][i] for i in range(len(lst))]
print(b) #[1, 5, 9]