python基础03

python是弱类型语言不像c语言,java那样需要定义变量类型
定义变量的语法为: 变量名 = 变量值
在python中，只要定义了一个变量，而且它有数据，那么它的类型就已经确定了，不需要咱们开发者主动的去说明它的类型，系统会自动辨别。也就是说在使用的时候 “变量没有类型，数据才有类型”
对象有类型，变量无类型
在这里插入图片描述
查看数据类型
使用type（）可以查看变量的类型

a=123
print(type(a)) #<class 'int'>
b="123"
print(type(b)) #<class 'str'>

查看对象的内存地址
使用id() 可以查看每个对象的内存地址

a=1
b=2
print(id(a))
print(id(b))

140723439867552
140723439867584

a=1
b=1
print(id(a))
print(id(b))

140723439867552
140723439867552

标识符和关键字
命名规则
标识符由字母、下划线和数字组成，且数字不能开头。
严格区分大小写。
不能使用关键字。
命名规范
标识符命名要做到顾名思义
小驼峰式命名法（lower camel case）：第一个单词以小写字母开始；第二个单词的首字母大写，例如：myName、aDog
大驼峰式命名法（upper camel case）：每一个单字的首字母都采用大写字母，例如：FirstName、LastName.
还有一种命名法是用下划线“_”来连接所有的单词，比如send_buf. Python的命令规则遵循PEP8标准：
变量名，函数名和文件名全小写，使用下划线连接；类名遵守大驼峰命名法；常量名全大写；

关键字
关键字的概念一些具有特殊功能的标识符，这就是所谓的关键字。关键字，已经被python官方使用了，所以不允许开发者自己定义和关键字相同名字的标识符。

False     None    True   and      as       assert   break     class  
continue  def     del    elif     else     except   finally   for
from      global  if     import   in       is       lambda    nonlocal
not       or      pass   raise    return   try      while     with  
yield

输出
print()

print(123)
%分号这样的操作符，这就是python中格式化输出
age=18
print("我%d岁了" % age)

age=18
name="dyk"
print("%s%d岁了" % (name , age)) #dyk18岁了

在这里插入图片描述

c=1.2345
print("%.2f" % c) #1.23
format格式化输出
print("{0},{1}".format("python","java")) #python,java

print("i like {0:10} and {1:>15}".format("python","java"))  #i like python     and            java  
{0:10}表示第一个位置，有10个字符那么长
{1:>15}表示有15个字符那么长，并且是右对齐
{1:^15}表示居中对齐，<左对齐
print("i like {0:.2} and {1:.3}".format("python","java")) #i like py and jav
{0:.2}0代表的是传入的位置，.2表示的对于传入的字符串截取前两个字符

a=12
c=13.23
print("{0:d}and{1:f}".format(a,c))#12and13.230000
print("{0:4d}and{1:.2f}".format(a,c)) #  12and13.23
{0:4d}第一个位置的长度是4
{1:.2f}第二个位置保留两位小数

输入
input
input()会把用户输入的任何值都作为字符串来对待

a=input()  #123
print(type(a)) #<class 'str'>

在这里插入图片描述

print(int("123"))  #123
print(type(int("123"))) #<class 'int'>
print(int(True)) #1
print(int(False)) #0

# 以下两种情况将会转换失败
123.45 和 abc 字符串，都包含非法字符，不能被转换成为整数，会报错
print(int("123.45"))
print(int("abc"))

# 使用int()函数进行类型转换时，还可以传入两个参数，第二个参数用来表示进制。
print(int("13",8)) #11 八进制的13对应的10进制的11
print(int("13",16)) #19 16进制的13对应的10进制的19
print(int("13",10)) #10 
#print(int("13",2)) 会报错，因为二进制最大值是1，

转化为浮点数
a=float("12.34")
print(a)  #12.34
print(type(a))  #<class 'float'>

b=float(10)
print(b) #10.0

转化为字符串
s1=str(12)
s2=str(12.34)
s3=str(True)
s4=str(False)
print(type(s1),type(s2),type(s3),type(s4)) #<class 'str'> <class 'str'> <class 'str'> <class 'str'>

转化为布尔值
print(bool(''))
print(bool(""))
print(bool(0))      
print(bool({}))
print(bool(None))  false

在python中，只有空字符串'',""，数字0,空字典{},空列表[],空元组(),和空数据None会被转换成为False,其他的都会被转换成为True

算术运算符
在这里插入图片描述

a=1+2   #3
print(a)
b=2-1  #1
print(b)
c=1*2  #2
print(c)
d=3/2  #1.5
print(d)
e=3//2   #1
print(e)
f=3%2   #1
print(f)
g=3**2   #9
print(g)

算术运算符在字符串的使用

s1="hello"
s2="python"
s3=s1+s2
print(s3)  #hellopython

注意：如果是数字和字符串相加会直接报错

数字与字符串相乘，会将这个字符串重复多次

s1="hello"
print(s1*3) #hellohellohello

赋值运算符

单个变量赋值
a=1

同时为多个变量赋值（使用等号连接）
a=b=1

多个变量赋值（使用逗号分隔）
a,b,c=1,2,3
print(a,b,c)

a,b,c=(1,2,3)
print(a,b,c)
个数一定要对应否则会赋值失败

交换两个变量
a=1
b=2
t=a
a=b
b=t
print(a,b)

或者
a=1
b=2
a,b=b,a
print(a,b)

在这里插入图片描述
注意：赋值运算符是从右往左运算，将等号右边的值赋值给等号左边，所以，等号的左边一定不能是常量或者表达式

比较运算符
在这里插入图片描述
注意赋值符号是一个等于而等于是连个==

字符串使用比较运算符
数字和字符串做==运算结果是false。除了 ==以外的逻辑运算时，会直接报错

如果两个字符串比较，会将每个字符都转换成对应的编码，然后逐一进行对比

s1='abc'
s2='aaa'
s3='b'
print(s1>s2) #True
print(s1>s3) #False

在这里插入图片描述

A and B  首先运算A,如果A的值是true，就计算B,并将B的结果返回最后的结果
如果A的值是false，那么就不计算B了 这也称作短路
A or B 首先运算A,如果A的值是false，就计算B，并将B的结果返回最后的结果
如果A的值是true，那么就不会计算B了


a = 5

a > 2 and print('123')
a < 2 and print('456')

a >2 or print('789')
a <2 or print('101')
运行结果为

123
101
因为 and 当左边条件为false时就不会执行右边的条件了 所以不会打印456
同理 or 当左边条件为true时就不会执行右边的条件了，所以不会打印789

位运算
在这里插入图片描述
运算符的优先级

条件判断语句

格式
    if 要判断的条件:
        条件成立时，要做的事情


if-else的使用格式
    if 条件:
        满足条件时的操作
    else:
        不满足条件时的操作


elif的使用格式如下:
    if xxx1:
        事情1
    elif xxx2:
        事情2
    elif xxx3:
        事情3

说明:

当xxx1满足时，执行事情1，然后整个if结束
当xxx1不满足时，那么判断xxx2，如果xxx2满足，则执行事情2，然后整个if结束
当xxx1不满足时，xxx2也不满足，如果xxx3满足，则执行事情3，然后整个if结束

注意：代码的缩进为一个tab键，或者4个空格

if嵌套的格式

    if 条件1:

        满足条件1 做的事情1
        满足条件1 做的事情2

        if 条件2:
            满足条件2 做的事情1
            满足条件2 做的事情2

区间比较:
在Python中允许类似于 5<a<10 的写法，这种写法在很多编程语言里都是不允许的，需要使用逻辑与运算符进行连接。

a=3
print(2<a<5) #true

三元运算符:

格式： 
变量 = 值1 if 条件 else 值2 
当条件成立时把 值1 赋值给变量，条件不成立时把 值2 赋值给变量，
其实就是对if...else 语句的一种简写。


a=10
b=5
c=a if a>b else b
print(c) #10

循环语句
while 语法

while 判断条件:
    代码块

i=0
while(i<10):
    i+=1 #i的值一定要变化否则会造成死循环
    print(i)

if语句和循环语句的区别

区别在于，if语句只会执行一次判断条件，条件成立以后，只会执行一次代码块；而while语句，会先执行一次判断条件，如果条件成立，会执行一次代码块，代码块执行完成以后，会再次判断条件语句，如果还成立，将会再执行代码语句… 直到最后条件不成立。

for循环的格式

for 临时变量 in 列表或者字符串等可迭代对象:
    循环满足条件时执行的代码
for s in "python":
    print(s)


for i in range(5): #表示取不到5，默认从0开始 左闭右开
    print(i)

range
range可以生成数字供for循环遍历，它可以传递三各参数，分别表示起始,结束，和步长
起始是闭区间，结束是开区间

上面那个等价于
for i in range(0,5): #当不指定步长的时候默认为1   0-4
    print(i)

for i in range(0,7,2): #0,2,4,6
    print(i)

break和continue

for i in range(6): #0,1,2,3
    if(i==4):
        break #结束整个循环。
    print(i)

for i in range(6): #0,1,2,3,5
    if(i==4):
        continue #结束本次循环，开始下一轮循环。
    print(i)

在Python中，break和continue只能用于循环语句中。
break和continue在嵌套循环中使用时，只对最内层循环有效。

打印九九乘法表

for i in range(1,10):
    for j in range(1,i+1):
        print("%d*%d=%d"%(j,i,i*j),end="	")
    print()

在Python中，循环语句还可以和else语句联合使用。

while 判断条件:
  条件成立时，循环体代码
else:
  条件不成立时，执行的代码

字符串

下标和切片
切片
- 字符串常见操作
- - len
  - max
  - min
  - in / not in
- 查找
- - find
  - rfind
  - index
  - rindex
  - startswith
  - endswith
  - isalpha
  - isdigit
  - isalnum
  - count
- 替换
- - split
  - rsplit
  - splitlines
  - partition
  - rpartition
  - title
  - lower
  - upper
- 空格处理
- ljust
- rjust
- - center
- lstrip
- rstrip
- strip
- 列表
- - insert
  - extend
  - del
  - pop
  - remove
  - sort
- reverse
- 元组
- - count, index
- 字典
- set
- - add
  - update
  - remove
  - discard
  - pop
  - eval
  - dumps
  - loads
- 函数
- - 匿名函数 lambda表达式
  - Python中使用函数作为参数的内置函数和类:
  - 高阶函数
  - 闭包
- 模块
- - 导入模块
  - OS模块
  - sys模块
  - math模块
  - random模块
  - datetime模块
  - time模块
  - calendar模块

下标和切片

下标/索引
注意下标是从0开始的

a="dyk"
print(a[0]) #d
print(a[1]) #y
print(a[2]) #k
#print(a[3]) #报错
print(a[-1]) #k

遍历
所谓遍历，可以理解为按照一定的规则(一般情况下就是数据的下标)，访问每一个数据。不是所有的数据都能够被遍历，字符串是可迭代对象，能够进行遍历。

a="dykisatc"
for i in range(len(a)):
    print(a[i],end='')
print()
for i in a:
    print(i,end='')
print()
i=0
while i<len(a):
    print(a[i],end='')
    i+=1 #i一定要变化否则会死循环

切片

切片的语法：[起始:结束:步长]，也可以简化使用 [起始:结束]
注意：选取的区间从"起始"位开始，到"结束"位的前一位结束（不包含结束位本身)，步长表示选取间隔。


a="dykisatc"
#索引是通过下标取得某一个元素
#切片是通过下标取某一段元素
#左闭右开
print(a[0:len(a)]) #dykisatc
print(a[2]) #k
print(a[2:6]) #kisa 不含下标为6的
print(a[:]) #dykisatc
print(a[1:]) #ykisatc 从下标为1开始，取出 后面所有的元素（没有结束位）
print(a[:4])  # 从起始位置开始，取到下标为4的前一个也就是下标3
print(a[-4:-1]) #sat 从倒数第四个开始，取到最后一个的前一个
print(a[0:8:2])#dkst 从第一个开始，取到下标为7（下标为8的前一个）步长为2

#python字符串快速反转
print(a[::-1]) #ctasikyd

字符串常见操作

获取长度:len
查找内容:find,index,rfind,rindex
判断:startswith,endswith,isalpha,isdigit,isalnum,isspace
计算出现次数:count
替换内容:replace
切割字符串:split,rsplit,splitlines,partition,rpartition
修改大小写:capitalize,title,upper,lower
空格处理:ljust,rjust,center,lstrip,rstrip,strip
字符串拼接:join

注意：在Python中，字符串是不可变的！所有的字符串相关方法，都不会改变原有的字符串，都是返回一个结果，在这个新的返回值里，保留了执行后的结果！

len

len函数可以获取字符串的长度。

str="hello python"
print(len(str)) #12包括中间的空格

max

max函数统计最大值

str="hellopython"
print(max(str))  #y

min

min函数统计最小值

str="hellopython"
print(min(str))  #e

max（）和min（）都是基于字符编码的内容比较的

in / not in

判断字符串是否存在

str="hellopython"
print("hello" in str) #True

in或not in 区分大小写

查找

find

查找指定内容在字符串中是否存在，如果存在就返回该内容在字符串中第一次出现的开始位置索引值，如果不存在，则返回-1.

格式:
S.find(sub[, start[, end]]) -> int
s.find(要查找的字符串，起始位置，结束位置) #也是左闭右开
print(str.find("hello")) #0
print(str.find("python")) #6
print(str.find("java"))  #-1
print(str.find("hello",6)) #-1 从下标为6的位置开始查找hello
print(str.find("hello",0,4)) #-1 从下标为为0的位置开始，到下标为3结束查找hello
print(str.find("hello",0,5)) #0 从下标为为0的位置开始，到下标为4结束查找hello

rfind

类似于 find()函数，不过是从右边开始查找。

index

S.index(sub[, start[, end]]) -> int

跟find()方法一样，只不过，find方法未找到时，返回-1,而str未找到时，会报一个异常。

rindex

类似于 index()，不过是从右边开始。

python提供了非常丰富的方法，可以用来对一个字符串进行判断。

startswith

判断字符串是否以指定内容开始。语法格式:

S.startswith(prefix[, start[, end]]) -> bool


str="hello python"
print(str.startswith("hello"))  #True
print(str.startswith("hel",0,3))    #True
print(str.startswith("hel",0,2))    #False
print(str.startswith("python")) #False

endswith

判断字符串是否以指定内容结束

str="hello python"
print(str.endswith("python")) #True
print(str.endswith("hon"))  #True

isalpha

判断字符串是否是纯字母。

str="hello python"
str1="hellopython"

print(str.isalpha()) #False 因为中间有空格
print(str1.isalpha()) #True

isdigit

判断一个字符串是否是纯数字，只要出现非0~9的数字，结果就是False

str="hello python"
str1="123"
print(str.isdigit()) #False
print(str1.isdigit()) #True

isalnum

判断是否由数字和字母组成。只要出现了非数字和字母，就返回False.

str = 'abcd'
print(str.isalnum())  # True
str = '1234'
print(str.isalnum()) # True
str = 'abcd1234'
print(str.isalnum()) # True
str = 'abcd1234_'
print(str.isalnum()) # False
str="@110";
print(str.isalnum()) #False

count

在整个字符串中间统计某个字符串出现的次数

语法格式:
S.count(sub[, start[, end]]) -> int

str="you are a big big pig";
print(str.count("big")) #2 big出现了两次
print(str.count("a"))  #2

替换

替换字符串中指定的内容，如果指定次数count，则替换不会超过count次。

str="你好python，我是dyk,世界真美好"
newstr=str.replace('好','很好')
print(str) #你好python，我是dyk,世界真美好
print(newstr) #你很好python，我是dyk,世界真美很好

newstr=str.replace('好',"很好",1) #指定替换的次数
print(newstr) #你很好python，我是dyk,世界真美好 两处好,只有第一处替换了

内容分隔
内容分隔主要涉及到split,splitlines,partition和rpartition四个方法。

split

以指定字符串为分隔符切片，如果 maxsplit有指定值，则仅分隔 maxsplit+1 个子字符串。返回的结果是一个列表。

str="你好python,我是dyk,世界真美好"
res=str.split()
print(res) #['你好python，我是dyk,世界真美好'] 默认使用空格分隔

res=str.split(',') #以,分隔
print(res) #['你好python', '我是dyk', '世界真美好']

res=str.split('好')
print(res) #['你', 'python,我是dyk,世界真美', '']

res=str.split('好',1) #已好为分隔符，最多分成两份
print(res)

rsplit

用法和split基本一致，只不过是从右往左分隔

splitlines

按照行分隔，返回一个包含各行作为元素的列表

mystr = 'hello 
world java'
print(mystr.splitlines())   #['hello ', 'world java']

mystr = 'hello 
world
java'
print(mystr.splitlines())   #['hello ', 'world', 'java']

partition

把mystr以str分割成三部分,str前，str和str后，三部分组成一个元组

res=str.partition('好')
print(res) #('你', '好', 'python,我是dyk,世界真美好')

rpartition

类似于 partition()函数,不过是从右边开始.

修改大小写
修改大小写的功能只对英文有效，主要包括，首字母大写capitalize,每个单词的首字母大写title,全小写lower,全大写upper.

capitalize
第一个单词的首字母大写。

str="hello python"
print(str.capitalize()) #Hello python

title

每个单词的首字母大写。

str="hello python"
print(str.title())#Hello Python

lower

所有都变成小写。

str="HELLO PYTHON"
print(str.lower())#hello python

upper

str="hello python"
print(str.capitalize()) #Hello python


print(str.title())#Hello Python

str="HELLO PYTHON"
print(str.lower())#hello python

str="hello python"
print(str.upper()) #HELLO PYTHON

空格处理

ljust

返回指定长度的字符串，并在右侧使用空白字符补全(左对齐)

rjust

返回指定长度的字符串，并在左侧使用空白字符补全(右对齐)。

center

返回指定长度的字符串，并在两端使用空白字符补全(居中对齐)

str="hello python"
print(str.ljust(20)) #hello python

print(str.rjust(20))#        hello python

print(str.center(20)) #    hello python

lstrip

删除字符串左边的空白字符。

rstrip

删除字符串右边的空白字符。

strip

删除字符串两断的空白字符。

str="    hello    "
print(str.lstrip()) #hello    
print(str.rstrip()) #    hello
print(str.strip())  #hello

字符串拼接
把参数进行遍历，取出参数里的每一项，然后再在后面加上该字符串

作用：可以把列表或者元组快速的转变成为字符串，并且以指定的字符分隔。

语法格式
s.join(iterable)

str='a'
print(str.join('bcd')) #bacad
print(str.join(['aa','bb','cc'])) #aaabbacc
print(str.join(('aa','bb','cc'))) #aaabbacc
print(''.join(('aa','bb','cc'))) #aabbcc

字符串运算符

字符串和字符串之间能够使用加法运算符，作用是将两个字符串拼接成为一个字符串。例如:‘hello’ + 'world’的结果是 ‘helloworld’
字符串和数字之间可以做乘法运算，结果是将指定的字符串重复多次。例如:‘hello’*2的结果是hellohello
字符串和字符串之间，如果使用比较运算符进行计算，会获取字符对应的编码，然后进行比较。
除上述几种运算符以外，字符串默认不支持其他运算符。

字符和编码相互转换
使用chr和ord方法，可以实现字符和编码之间的相互转换。


# 使用ord方法，可以获取一个字符对应的编码
print(ord('a'),ord('A')) #97 65
# 使用chr方法，可以获取一个编码对应的字符
print(chr(97),chr(65)) #a A

编码规则

s1 = '你'.encode('utf8')  # 将字符 你 按照utf8格式编码称为二进制
print(type(s1))  # <class 'bytes'>
print(s1)  # b'xe4xbdxa0'

s2 = s1.decode('utf8') # 将二进制按照utf8格式解码称为字符串
print(s2)

s3 = '你'.encode('gbk') # 将字符 你 按照gbk格式转换称为二进制
print(s3)  # b'xc4xe3'

s4 = s3.decode('gbk')  # 将二进制按照gbk格式解码称为字符
print(s4)

成员运算符
成员运算符 (in 和 not in) 可以用来快速的判断元素是否在指定的可迭代对象里，语法格式要判断的元素 in 可迭代对象。

msg = 'hello'
char = input('请输入一个字符:')

# 使用字符串的 find 方法可以判断字符是否存在
if msg.find(char) != -1:
    print('您输入的字符存在')
else:
    print('您输入的字符不存在')

# 使用 in 运算符可以更加方便的查看字符是否存在
if char in msg:
    print('您输入的字符存在')
else:
    print('您输入的字符不存在')

not in 运算符
和 in 运算符的使用方式一致，只不过 not in 用来判断元素是否不在指定的字符串里。

注意
不是所有的数据都能使用身份运算符，身份运算符后面只能是一个可迭代对象。

'h' in 'hello'  
'zhangsan' in ['lisi','henry','merry','jack']

1 in 123 # 报错，数字 123 不是一个可迭代对象

字符串的format方法
str.format() 方法通过字符串中的大括号{} 来识别替换字段 replacement field，从而完成字符串的格式化。
替换字段由字段名 field name 和转换字段 conversion field 以及格式说明符 format specifier 组成，即一般形式为 {字段名!转换字段:格式说明符}。
字段名分为简单字段名 simple field name 和复合字段名 compound field name。而转换字段和格式说明符都是可选的。

序号	选项	描述
1	fill	空白的填充方式，默认使用空格实现空白部分的填充
2	align	定义数据的对齐方式，在指定数据最小显示宽度时有效 -------------------- <:左对齐 >:右对齐 ^ 居中对齐
3	sign	符号签名 + ：所有数字均带有符号 -:仅负数带有符号空格整数前面带符号，负数前面带符号
4	#	数字进制转换自动配置，自动在二进制，八进制，十六进制数值前添加对应的0b，0o，0x标记
5	,	自动在每三个数字间添加,分隔
6	width	定义十进制的小数显示宽度，如果未指定，则由实际内容来决定宽度
7	.precision	数据保留精度的位数
8	type	数据的类型例如字符串用"%s" 整数用"%d"

省略字段名
大括号内省略字段名，传递位置参数。

替换字段形式： {}
注意：大括号个数可以少于位置参数的个数，反之不然

print("我是{} 来自 {} {}岁".format('dyk','jm',18))
#我是dyk 来自 jm 18岁

print("我是{} 来自 {} 岁".format('dyk','jm',18))
大括号的个数可以少于位置参数的个数反之报错

数字字段名
可以通过数字形式的简单字段名传递位置参数。

数字必须是大于等于 0 的整数。
带数字的替换字段可以重复使用。
数字形式的简单字段名相当于把 format 中的所有位置参数整体当作一个元组，通过字段名中的数字进行取值。即 {0} 等价于 tuple[0]，所以大括号内的数字不能越界。

print("我是{0} 来自 {1} {2} 岁".format('dyk','jm',18))

列表

定义列的格式：[元素1, 元素2, 元素3, …, 元素n]

列表中的元素可以是不同类型的
使用下标获取列表元素

arr=[12,'dyk',12.3]

print(arr[0]) #12
print(arr[1]) #dyk
print(arr[2]) #12.3

列表的数据操作
添加元素有一下几个方法:

append 在末尾添加元素
insert 在指定位置插入元素
extend 合并两个列表

arr=[12,'dyk',12.3]

arr.append('cb')
print(arr) //[12, 'dyk', 12.3, 'cb']

insert

insert(index, object) 在指定位置index前插入元素object

arr=[12,'dyk',12.3]

arr.insert(1,'lfw')
print(arr) #[12, 'lfw', 'dyk', 12.3]

extend

通过extend可以将另一个集合中的元素逐一添加到列表中

arr=[12,'dyk',12.3]

arr2=[1,2,3]

arr.extend(arr2)

print(arr) #[12, 'dyk', 12.3, 1, 2, 3]

extend和append的区别
extend添加两个列表时，会把添加的列表拆开添加
简单来说 append是整建制的增加，exend（）是个体化扩编

arr=[12,'dyk',12.3]

arr2=[1,2,3]

arr.append(arr2)

print(arr) #[12, 'dyk', 12.3, [1, 2, 3]]

修改元素

我们是通过指定下标来访问列表元素，因此修改元素的时候，为指定的列表下标赋值即可。

arr=[12,'dyk',12.3]

arr[1]='cb'

print(arr)  #[12, 'cb', 12.3]

查找元素

所谓的查找，就是看看指定的元素是否存在，以及查看元素所在的位置，主要包含一下几个方法：

in 和 not in
index 和 count
in, not in
python中查找的常用方法为：

in（存在）,如果存在那么结果为true，否则为false
not in（不存在），如果不存在那么结果为true，否则false

arr=[12,'dyk',12.3]

if('dyk' in arr):
    print('dyk存在')
else:
    print('不存在')

index和count

index用来查找元素所在的位置，如果未找到则会报错；count用来计算某个元素出现的次数。它们的使用和字符串里的使用效果一致。

arr=[12,'dyk',12.3,12]

print(arr.count(12)) #2
print(arr.index('dyk')) #1
print(arr.index(12, 1, 4)) #3  从下标为1到下标为3

删除元素
列表元素的常用删除方法有：

del

del：根据下标进行删除

arr=[12,'dyk',12.3,12]

del arr[1]
print(arr) #[12, 12.3, 12]

pop

pop：删除最后一个元素

arr=[12,'dyk',12.3,12]

arr.pop()
print(arr) #[12, 'dyk', 12.3]

remove

remove：根据元素的值进行删除

arr=[12,'dyk',12.3,12]

arr.remove('dyk')
print(arr) #[12, 12.3, 12]

排序(sort, reverse)
可改为倒序，由大到小。

sort

sort方法是将list按特定顺序重新排列，默认为由小到大，参数reverse=True

arr=[1,3,2,5,4]

arr.sort()//默认从小到大排
print(arr) #[1, 2, 3, 4, 5]

arr=[1,3,2,5,4]

arr.sort(reverse=True)从大到小排
print(arr) #[5, 4, 3, 2, 1]

reverse

reverse方法是将list逆置。

arr=[1,3,2,5,4]

arr.reverse()
print(arr) #[4, 5, 2, 3, 1]

列表的遍历

arr=[1,3,2,5,4]

for i in arr:
    print(i,end=' ') #1 3 2 5 4 

arr=[1,3,2,5,4]

for i in range(len(arr)):
    print(arr[i],end=' ')

列表嵌套
一个列表中的元素又是一个列表，那么这就是列表的嵌套，类似于其他语言的多维数组

arr=[1,[2,3,4],[5,6,7]]

print(arr[1][0])#2
print(arr[2][2])#7
print(arr[0][0])#报错
print(arr[0])#1

列表推导式

arr=[i for i in range(10) if(i%2)]
print(arr) #[1, 3, 5, 7, 9]奇数

arr1=[i for  i in range(10) if(i%2==0)]
print(arr1)#[0, 2, 4, 6, 8]偶数

可变数据类型和不可变数据类型
可变数据类型如果修改值，内存地址会发生变化
不可变数据类型如果修改值，内存地址不会发生变化

不可变类型：字符串，数字，元组
可变数据类型：列表，字典，集合
列表的复制

arr=[1,2,3,4,5]
arr1=arr

print(arr1) #[1, 2, 3, 4, 5]
arr[0]=6
print(arr1) #[6, 2, 3, 4, 5]

列表的copy方法
使用列表的copy方法，可以直接将原来的列表进行复制，变成一个新的列表，这种复制方式是浅复制。

arr=[1,2,3,4,5]
arr1=arr.copy() # 调用列表的copy方法，可以复制出一个新的列表
# 修改新列表里的数据，不会影响到原有列表里的数据
print(arr1) #[1, 2, 3, 4, 5]
arr[0]=6
print(arr1) #[1, 2, 3, 4, 5]

copy模块的使用
除了使用列表的copy方法以外，Python还提供了copy模块来复制一个对象。copy模块提供了浅复制和深复制两种方式，它们的使用方式相同，但是执行的效果有一定的差异

浅拷贝
浅拷贝是对于一个对象的顶层拷贝，通俗的理解是：拷贝了引用，并没有拷贝内容。

import copy

words1 = ['hello', 'good', ['yes', 'ok'], 'bad']

# 浅拷贝只会拷贝最外层的对象，里面的数据不会拷贝，而是直接指向
words2 = copy.copy(words1)

words2[0] = '你好'
words2[2][0] = 'no'

print(words1)  # ['hello', 'good', ['no', 'ok'], 'bad']
# wrods2 里的 yes 被修改成了 no
print(words2)  # ['你好', 'good', ['no', 'ok'], 'bad']

深拷贝
深拷贝是对于一个对象所有层次的递归拷贝。

import copy

words1 = ['hello', 'good', ['yes', 'ok'], 'bad']

# 深拷贝会将对象里的所有数据都进行拷贝
words2 = copy.deepcopy(words1)

words2[0] = '你好'
words2[2][0] = 'no'

print(words1)  # ['hello', 'good', ['yes', 'ok'], 'bad']
print(words2)  # ['你好', 'good', ['no', 'ok'], 'bad']

元组

Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。

访问元组
通过下标访问

arr=(1,2,3,4,5)

print(arr[0]) #1

元组是不可变数据类型， python中不允许修改元组的数据，包括不能删除其中的元素，和添加元素

定义只有一个数据的元组
定义只有一个元素的元组，需要在唯一的元素后写一个逗号

arr=(1)
print(type(arr)) #<class 'int'>

arr1=(1,) # 只有一个元素的元组，必须要在元素后写一个逗号
print(type(arr1)) #<class 'tuple'>

count, index

index和count与字符串和列表中的用法相同

arr=(1,2,3,4,5,1)

print(arr.index(2))#1
print(arr.count(1))#2

字典

定义字典的格式：{键1:值1, 键2:值2, 键3:值3, …, 键n:值n}

stu={'name':'dyk','age':18,'sex':'男'}

print(stu) #{'name': 'dyk', 'age': 18, 'sex': '男'}
print(stu['name']) #dyk

字典和列表一样，也能够存储多个数据
列表中找某个元素时，是根据下标进行的；字典中找某个元素时，是根据’名字’（就是冒号:前面的那个值）
字典的每个元素由2部分组成，键:值
键可以使用数字、布尔值、布尔值、元组等不可变数据类型，但是一般习惯使用字符串
每个字典里的key都是唯一的，如果出现了多个key,后面的value会覆盖前一个key对应的value.

查看元素
除了使用key查找数据，还可以使用get来获取数据

stu={'name':'dyk','age':18,'sex':'男'}

print(stu['name']) #dyk
print(stu.get('age'))#18
#print(stu['id'])# 获取不存在的key，会发生异常
print(stu.get('id'))# 获取不存在的key，获取到空的内容，不会出现异常

print(stu.get('id', 20181117026)) # 获取不存在的key, 可以提供一个默认值。

注意，获取默认值不会修改字典内容。

修改元素
字典的每个元素中的数据是可以修改的，只要通过key找到，即可修改

stu={'name':'dyk','age':18,'sex':'男'}

stu['age']=19
print(stu) #{'name': 'dyk', 'age': 19, 'sex': '男'}

添加元素

如果在使用变量名[‘键’] = 数据时，这个“键”在字典中，不存在，那么就会新增这个元素

stu={'name':'dyk','age':18,'sex':'男'}

stu['age']=19 #存在age就改变原来对应的值
stu['height']=180 #不存在height就添加
print(stu) #{'name': 'dyk', 'age': 19, 'sex': '男', 'height': 180}

删除元素
del
clear()

del删除指定的元素

stu={'name':'dyk','age':18,'sex':'男'}

del stu['name']  #删除name
print(stu) #{'age': 18, 'sex': '男'}

del删除整个字典

stu={'name':'dyk','age':18,'sex':'男'}

del stu #报错 name 'stu' is not defined

clear清空整个字典

stu={'name':'dyk','age':18,'sex':'男'}

stu.clear()
print(stu) #{}

字典遍历
遍历字典的key（键）

stu={'name':'dyk','age':18,'sex':'男'}

for k in stu.keys():
    print(k) #name age sex
    print(stu.get(k)) #dyk 18 男

遍历字典的value（值）

stu={'name':'dyk','age':18,'sex':'男'}

for k in stu.values():#只能取得value值
    print(k,end=' ')#dyk 18 男

遍历字典的项（元素）

stu={'name':'dyk','age':18,'sex':'男'}

for item in stu.items():
    print(item,end=' ') #('name', 'dyk') ('age', 18) ('sex', '男')
    print(item[0],item[1]) #name dyk

遍历字典的key-value（键值对）

stu={'name':'dyk','age':18,'sex':'男'}

for key,value in stu.items():
    print(key,value,end=' ') #name dyk age 18 sex 男

set

集合（set）是一个无序的不重复元素序列，可以使用大括号 { } 或者 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：
parame = {value01,value02,...}
或者
set(value)
当{}里面是键值对的时候认为是字典，否则是集合

set常见方法列表
在这里插入图片描述

添加元素

add

将元素 x 添加到集合 s 中，如果元素已存在，则不进行任何操作。

st={1,2,3,4,5}
st.add(6)
print(st)

还有一个方法，也可以添加元素，且参数可以是列表，元组，字典等，语法格式如下：

update

s.update( x )
x 可以有多个，用逗号分开。

st={1,2,3,4,5}
st1={7,8,9}
li=[10,11,12]
st.update(st1) #{1, 2, 3, 4, 5, 7, 8, 9}
print(st)
st.update(li) #{1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12}
print(st)

移除元素

remove

将元素 x 从集合 s 中移除，如果元素不存在，则会发生错误。

st={1,2,3,4,5}

st.remove(1)
print(st) #{2, 3, 4, 5}
st.remove(6)
print(st) #报错

此外还有一个方法也是移除集合中的元素，且如果元素不存在，不会发生错误。格式如下所示：

discard

st={1,2,3,4,5}

st.discard(1)
print(st) #{2, 3, 4, 5}
st.discard(6)
print(st) #不报错 {2, 3, 4, 5}

我们也可以设置随机删除集合中的一个元素，语法格式如下：

pop

st={1,2,3,4,5}

st.pop() 
print(st) #{2, 3, 4, 5}随机删除一个

执行字符串

eval

使用Python内置的eval函数，可以执行字符串里的Python代码。使用这种方式，可以将字符串转换成为其他类型的数据

x = '1+1'
print(eval(x))  # 2
print(type(eval(x)))  # <class 'int'>

y = '{"name":"zhangsan","age":18}'
print(eval(y))
print(type(eval(y)))  # <class 'dict'>

print(eval('1 > 2'))  # False

eval('input("请输入您的姓名:")')

转换成为字符串
JSON(JavaScriptObjectNotation, JS对象简谱)是一种轻量级的数据交换格式，它基于 ECMAScript 的一个子集，采用完全独立于编程语言的文本格式来存储和表示数据。JSON本质是一个字符串

JSON的功能强大，使用场景也非常的广，目前我们只介绍如何使用Python的内置JSON模块，实现字典、列表或者元组与字符串之间的相互转换。

dumps

使用json的dumps方法，可以将字典、列表或者元组转换成为字符串。

import json

stu ={'name':'dyk','age':18,'sex':'male'}

ss=json.dumps(stu)
print(ss) #{"name": "dyk", "age": 18, "sex": "male"}
print(type(ss)) #<class 'str'>

loads

使用json的loads方法，可以将格式正确的字符串转换成为字典、列表。

import json

str='{"name": "dyk", "age": 18, "sex": "male"}'
dic=json.loads(str)
print(dic)  #{'name': 'dyk', 'age': 18, 'sex': 'male'}
print(type(dic)) #<class 'dict'>

字符串、列表、元组、字典和集合，它们有很多相同点，都是由多个元素组合成的一个可迭代对象，它们都有一些可以共同使用的方法。

在这里插入图片描述
+

加法运算符可以用于字符串、列表和元组，用来拼接多个可迭代对象，不能用于字典和集合

>>> "hello " + "world"
'hello world'
>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> ('a', 'b') + ('c', 'd')
('a', 'b', 'c', 'd')

减法只能用于集合里，用来求两个集合的差集。
>>> {1, 6, 9, 10, 12, 3} - {4, 8, 2, 1, 3}
{9, 10, 12, 6}

加法运算符可以用于字符串、列表和元组，用来将可迭代对象重复多次，同样不能用于字典和集合

>>> 'ab' * 4
'ababab'
>>> [1, 2] * 4
[1, 2, 1, 2, 1, 2, 1, 2]
>>> ('a', 'b') * 4
('a', 'b', 'a', 'b', 'a', 'b', 'a', 'b')

in
in和not in成员运算符可以用于所有的可迭代对象。但是需要注意的是，in 和 not in 在对字典进行判断时，是查看指定的key是否存在，而不是value.

>>> 'llo' in 'hello world'
True
>>> 3 in [1, 2]
False
>>> 4 in (1, 2, 3, 4)
True
>>> "name" in {"name":"chris", "age":18}
True

函数

在开发程序时，需要某块代码多次执行。为了提高编写的效率以及更好的维护代码，需要把具有独立功能的代码块组织为一个小模块，这就是函数。

函数定义和调用

定义函数的格式如下：
def 函数名():
    代码

调用函数
定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它

调用函数很简单的，通过 函数名() 即可完成调用

def add():
    return 1+2


print(add())#3

函数定义好以后，函数体里的代码并不会执行，如果想要执行函数体里的内容，需要手动的调用函数。
每次调用函数时，函数都会从头开始执行，当这个函数中的代码执行完毕后，意味着调用结束了。
当然了如果函数中执行到了return也会结束函数。

函数参数

def add(a,b):
    return a+b

print(add(1,2))#3

注意点：

在定义函数的时候，小括号里写等待赋值的变量名形参
在调用函数的时候，小括号里写真正要进行运算的数据实参
定义时小括号中的参数，用来接收参数用的，称为 “形参”
调用时小括号中的参数，用来传递给函数用的，称为 “实参”

调用函数时参数的顺序

def test(a,b):
    print(a,b)
 
test(1,2)  # 位置参数
1 2
test(b=1,a=2)  # 关键字参数
2 1

test(b=1,2)  # 关键字参数写在位置参数之前会导致出错
  File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument

函数返回值
想要在函数中把结果返回给调用者，需要在函数中使用return

def add2num(a, b):
    c = a+b
    return c  # return 后可以写变量名

def add2num(a, b):
    return a+b  # return 后可以写计算表达式

局部变量
局部变量，就是在函数内部定义的变量
其作用范围是这个函数内部，即只能在这个函数中使用，在函数的外部是不能使用的
局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储
当函数调用时，局部变量被创建，当函数调用完成后这个变量就不能够使用了

全局变量
如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量

在函数外边定义的变量叫做全局变量
全局变量能够在所有的函数中进行访问

当函数内出现局部变量和全局变量相同名字时，函数内部中的变量名 = 数据此时理解为定义了一个局部变量，而不是修改全局变量的值

修改全局变量
函数中进行使用时可否进行修改呢？

a=10

def change():
    a=1

print(change()) #10


a=10

def change():
    global a
    a=1
    return a


print(change()) #1

如果在函数中出现global 全局变量的名字那么这个函数中即使出现和全局变量名相同的变量名 = 数据也理解为对全局变量进行修改，而不是定义局部变量
如果在一个函数中需要对多个全局变量进行修改，那么可以一次性全部声明，也可以分开声明

# 可以使用一次global对多个全局变量进行声明
global a, b
# 还可以用多次global声明都是可以的
# global a
# global b

查看所有的全局变量和局部变量

Python提供了两个内置函数globals()和locals()可以用来查看所有的全局变量和局部变量。

函数返回值
一个函数中可以有多个return语句，但是只要有一个return语句被执行到，那么这个函数就会结束了，因此后面的return没有什么用处

python中定义的函数如果没有使用return 语句，所有函数返回值的内容为None

一个函数返回多个数据的方式
return后面可以是元组，列表、字典等，只要是能够存储多个数据的类型，就可以一次性返回多个数据。

def divid(a, b):
    shang = a//b
    yushu = a%b 
    return shang, yushu  #默认是元组

result = divid(5, 2)
print(result)  # 输出(2, 1)

如果return后面有多个数据，那么默认是元组。

      def function():
          # return [1, 2, 3]
          # return (1, 2, 3)
          return {"num1": 1, "num2": 2, "num3": 3}

对返回的数据直接拆包

def get_my_info():
    high = 178
    weight = 100
    age = 18
    return high, weight, age  # 函数返回三个数据，会自动打包为元组

# result = get_my_info()  # result 接收到一个元组
# print(result)

my_high, my_weight, my_age = get_my_info()  # 直接把元组拆分为三个变量来使用，更加方便
print(my_high)
print(my_weight)
print(my_age)

拆包时要注意，需要拆的数据的个数要与变量的个数相同，否则程序会异常
除了对元组拆包之外，还可以对列表、字典等拆包

缺省参数
调用函数时，缺省参数的值如果没有传入，则取默认值。

a=10

def add(a,b=10):
    return a+b


print(add(1)) #11
print(add(1,2)) #3

在形参中默认有值的参数，称之为缺省参数

注意：带有默认值的参数一定要位于参数列表的最后面

不定长参数
时可能需要一个函数能处理比当初声明时更多的参数, 这些参数叫做不定长参数，声明时不会命名。

基本语法如下
def functionname([formal_args,] *args, **kwargs):
   """函数_文档字符串"""
   function_suite
   return [expression]

加了星号（*）的变量args会存放所有未命名的变量参数，args为元组

而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典.

如果很多个值都是不定长参数，那么这种情况下，可以将缺省参数放到 args的后面，但如果有*kwargs的话，kwargs必须是最后的

如果一个函数中需要定义可变参数，又需要定义关键字参数，关键字参数必须放在最后

符合参数的定义顺序为必选参数，默认参数，可变参数，命名关键参数，和关键字参数

可变、不可变类型

所谓可变类型与不可变类型是指：数据能够直接进行修改，如果能直接修改那么就是可变，否则是不可变

可变类型(修改数据，内存地址不会发生变化)有： 列表、字典、集合

不可变类型(修改数据，内存地址必定发生变化)有： 数字、字符串、元组

匿名函数 lambda表达式

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。

lambda函数的语法只包含一个语句，如下

lambda 参数列表: 运算表达式

sum=lambda a,b:a+b

print(sum(1,2)) #3

Lambda函数能接收任何数量的参数但只能返回一个表达式的值

匿名函数可以执行任意表达式(甚至print函数)，但是一般认为表达式应该有一个计算结果供返回使用。

python在编写一些执行脚本的时候可以使用lambda，这样可以接受定义函数的过程，比如写一个简单的脚本管理服务器。

Python中使用函数作为参数的内置函数和类:

函数名或类名	功能	参数描述
sorted函数	用来将一个无序列表进行排序	函数参数的返回值规定按照元素的哪个属性进行排序
filter类	用来过滤一个列表里符合规定的所有元素，得到的结果是一个迭代器	函数参数的返回值指定元素满足的过滤条件
map类	将列表里的每一项数据都执行相同的操作，得到的结果是一个迭代器	函数参数用来指定列表里元素所执行的操作
reduce函数	对一个序列进行压缩运算，得到一个值。python3以后，这个方法被移到了functools模块	函数参数用来指定元素按照哪种方式合并

在Python中，函数其实也是一种数据类型。

def test():
    return 'hello world'
print(type(test))  # <class 'function'>

函数对应的数据类型是 function,可以把它当做是一种复杂的数据类型。

既然同样都是一种数据类型，我们就可以把它当做数字或者字符串来处理。

高阶函数

函数做为另一个函数的参数

def add(a,fn):
    if a+fn(9,6)>5:
        return "ok"
    else :
        return "fail"

def dec(x,y):
    return x-y


print(add(5, dec)) #ok
print(add(1,dec))  #fail

传递的时候可以直接传名字，调用的时候只需要在名字后面加()即可

函数作为另一个函数的返回值
加小括号和不加小括号的区别

def test():
    print("我是test里面的内容")

def check():
    print("我是check里面的内容")
    return test()


check()  #我是check里面的内容 我是test里面的内容

def test():
    print("我是test里面的内容")

def check():
    print("我是check里面的内容")
    return test  # test 函数作为check函数的返回值


result=check() #把check 函数的返回值赋值给 result
print(type(result)) #<class 'function'>
#既然result是一个函数，那么就可以直接使用() 调用这个函数
result()  #我是check里面的内容  我是test里面的内容

闭包

函数只是一段可执行代码，编译后就“固化”了，每个函数在内存中只有一份实例，得到函数的入口点便可以执行函数了。函数还可以嵌套定义，即在一个函数内部可以定义另一个函数，有了嵌套函数这种结构，便会产生闭包问题。

如果在一个内部函数里，对在外部作用域（但不是在全局作用域）的变量进行引用，那么内部函数就被认为是闭包(closure).

def out_add(a):
    def in_add(b):
        return a+b
    return in_add

oa=out_add(1)
print(oa(2)) #3
print(out_add(4)(5)) #9

修改外部变量的值

使用 nonlocal 关键字

def outer(n):
    num = n
    def inner():
        nonlocal num  # 修改前使用nonlocal关键字对 num 变量进行说明
        num = num + 1
        return num
    return inner

print(outer(2)())

模块

导入模块

import 模块名

from 模块名 import 功能名

from 模块名 import *

import 模块名 as 别名

from 模块名 import 功能名 as 别名

OS模块

OS全称OperationSystem,即操作系统模块，这个模块可以用来操作系统的功能，并且实现跨平台操作。

os.getcwd()  # 获取当前的工作目录，即当前python脚本工作的目录

os.chdir("../") # 改变当前脚本工作目录，相当于shell下的cd命令

os.rename('123.txt','456.txt') # 文件重命名

os.remove('123.txt') # 删除文件

os.rmdir('demo')  # 删除空文件夹

os.mkdir('demo')  # 创建一个文件夹

os.listdir('C:\') # 列出指定目录里的所有文件和文件夹

os.name # nt->widonws posix->Linux/Unix或者MacOS

os.environ # 获取到环境配置

os.environ.get('PATH') # 获取指定的环境配置

os.path.abspath(path) # 获取Path规范会的绝对路径

os.path.exists(path)  # 如果Path存在，则返回True

os.path.isdir(path)  # 如果path是一个存在的目录，返回True。否则返回False

os.path.isfile(path) # 如果path是一个存在的文件，返回True。否则返回False

os.path.splitext(path)  # 用来将指定路径进行分隔，可以获取到文件的后缀名

sys模块

该模块提供对解释器使用或维护的一些变量的访问，以及与解释器强烈交互的函数。

import sys

sys.path # 模块的查找路径

sys.argv # 传递给Python脚本的命令行参数列表

sys.exit(code) # 让程序以指定的退出码结束

sys.stdin # 标准输入。可以通过它来获取用户的输入

sys.stdout # 标准输出。可以通过修改它来百变默认输出

sys.stderr # 错误输出。可以通过修改它来改变错误删除

math模块

math模块保存了数学计算相关的方法，可以很方便的实现数学运算。

import math

print(math.fabs(-100)) # 取绝对值

print(math.ceil(34.01))  #向上取整

print(math.factorial(5)) # 计算阶乘

print(math.floor(34.98))  # 向下取整

print(math.pi)   # π的值，约等于 3.141592653589793

print(math.pow(2, 10)) # 2的10次方

print(math.sin(math.pi / 6))  # 正弦值

print(math.cos(math.pi / 3))  # 余弦值

print(math.tan(math.pi / 2))  # 正切值

random模块

random 模块主要用于生成随机数或者从一个列表里随机获取数据。

print(random.random())  # 生成 [0,1)的随机浮点数

print(random.uniform(20, 30))  # 生成[20,30]的随机浮点数

print(random.randint(10, 30))  # 生成[10,30]的随机整数

print(random.randrange(20, 30))  # 生成[20,30)的随机整数

print(random.choice('abcdefg'))  # 从列表里随机取出一个元素

print(random.sample('abcdefghij', 3)) # 从列表里随机取出指定个数的元素

datetime模块

datetime模块主要用来显示日期时间，这里主要涉及 date类，用来显示日期；time类，用来显示时间；dateteime类，用来显示日期时间;timedelta类用来计算时间。

import datetime

print(datetime.date(2020, 1, 1))  # 创建一个日期

print(datetime.time(18, 23, 45)) # 创建一个时间

print(datetime.datetime.now())  # 获取当前的日期时间

print(datetime.datetime.now() + datetime.timedelta(3))  # 计算三天以后的日期时间

time模块

除了使用datetime模块里的time类以外，Python还单独提供了另一个time模块，用来操作时间。time模块不仅可以用来显示时间，还可以控制程序，让程序暂停(使用sleep函数)

print(time.time())  # 获取从1970-01-01 00:00:00 UTC 到现在时间的秒数

print(time.strftime("%Y-%m-%d %H:%M:%S")) # 按照指定格式输出时间

print(time.asctime()) #Mon Apr 15 20:03:23 2019

print(time.ctime()) # Mon Apr 15 20:03:23 2019

print('hello')
print(time.sleep(10)) # 让线程暂停10秒钟
print('world')

calendar模块

calendar模块用来显示一个日历，使用的不多，了解即可。

calendar.setfirstweekday(calendar.SUNDAY) # 设置每周起始日期码。周一到周日分别对应 0 ~ 6

calendar.firstweekday()# 返回当前每周起始日期的设置。默认情况下，首次载入calendar模块时返回0，即星期一。

c = calendar.calendar(2019)  # 生成2019年的日历，并且以周日为其实日期码
print(c)  #打印2019年日历

print(calendar.isleap(2000)) # True.闰年返回True,否则返回False

count = calendar.leapdays(1996,2010) # 获取1996年到2010年一共有多少个闰年

print(calendar.month(2019, 3))  # 打印2019年3月的日历
来自：https://blog.csdn.net/qq_44866153/article/details/110356327?ops_request_misc=%25257B%252522request%25255Fid%252522%25253A%252522160990234316780273658596%252522%25252C%252522scm%252522%25253A%25252220140713.130102334..%252522%25257D&request_id=160990234316780273658596&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-5-110356327.pc_search_result_no_baidu_js&utm_term=python%E5%9F%BA%E7%A1%80