零基础学Python，本文是我个人的随心笔记，希望对你有益！
注释：单行：#…… 多行：单引号（’’’） 双引号（”””）
基本数据类型：整数：int；浮点数：float（只有这两种）；str：字符串；bool：布尔类型；complete：复数；list:列表；tuple:元组；set:集合；dict:字典
1 >>> type(2)
2 <class 'int'>
3 >>> type(1.1)
4 <class 'float'>
5 >>> type(1+1.1)
6 <class 'float'>
7 >>> type(2/2)
8 <class 'float'>
9 >>> type(2//2)
10 <class 'float'>
11 >>> 2//2
12 1
13 >>> 2/2
14 1.0
15 >>> 2*2
16 4type()用来获取该表达式的数据类型
//: 除并取整
/ ：除之后商有一位小数
1 print("I", end=" ")
2 print("love ", end='')
3 print("you !") # I love you !（没有换行）进制转换
1 >>> 0b10 # 二进制
2 2
3 >>> 0o10 # 八进制
4 8
5 >>> 0x10 # 十六进制
6 16
7 >>> bin(0o10) # 八进制 转换 二进制
8 '0b1000'
9 >>> bin(10) # 十进制 转换 二进制
10 '0b1010'
11 >>> bin(0x10) # 十六进制 转换 二进制
12 '0b10000'
13 >>> int(0b10) # 二进制 转换 八进制
14 2
15 >>> int(0o10) # 十进制 转换 八进制
16 8
17 >>> int(0x10) # 十六进制 转换 八进制
18 16
19 >>> hex(0b10) # 二进制 转换 十六进制
20 '0x2'
21 >>> hex(0o10) # 八进制 转换 十六进制
22 '0x8'
23 >>> hex(10) # 十进制 转换 十六进制
24 '0xa'布尔类型
1 # True和False首字母都要大写
2 >>> type(True)
3 <class 'bool'>
4 >>> type(False)
5 <class 'bool'>
6 >>> int(True)
7 1
8 >>> int(False)
9 0
10 >>> bool(1)
11 True
12 >>> bool(0)
13 False
14 >>> bool(2)
15 True
16 >>> bool(2.2)
17 True
18 >>> bool(-2)
19 True
20 >>> bool('abc')
21 True
22 >>> bool('')
23 False
24 >>> bool([1,2,3])
25 True
26 >>> bool([])
27 False
28 >>> bool({1,2,3})
29 True
30 >>> bool({})
31 False
32 >>> bool(None)
33 False
34 >>> 36j # 输出复数
35 36jstr(不可变)：字符串 -> 单引号，双引号，三引号（成对出现）
1 >>> "let's go !"
2 "let's go !"
3 >>> '''
4 ... 1
5 ... 2
6 ... a
7 ... b
8 ... '''
9 '\n1\n2\na\nb\n'
10 >>> "let's go !"
11 "let's go !"
12 >>> '''
13 ... 1
14 ... 2
15 ... a
16 ... b
17 ... '''
18 '\n1\n2\n3\na\nb\n'
19 >>> """\n1\n2\na\nb\n"""
20 '\n1\n2\na\nb\n'
21 >>> print("""\n1\n2\n3\na\nb\n""")
22
23 1
24 2
25 3
26 a
27 b
28
29 结束format格式化函数
1 >>> "{} {}".format("hello","world") # 不设置指定位置，按默认顺序
2 'hello world'
3 >>> "{0} {1}".format("hello","world") # 设置指定位置
4 'hello world'
5 >>> "{1} {0} {1}".format("hello","world") # 设置指定位置
6 'world hello world'
7 >>> "网站名：{name}，地址：{url}".format(name="世界与你同在",url=" http://www.worldiwiu.ltd/main ") # 设置参数
8 '网站名：世界与你同在，地址：http://www.worldiwiu.ltd/main '
9 >>> site = {"name": "世界与你同在", "url": " http://www.worldiwiu.ltd/main "} # 通过字典设置参数
10 >>> "网站名：{name}，地址：{url}".format(**site) # 通过**可讲字典中的值分配给关键字参数
11 '网站名：世界与你同在，地址：http://www.worldiwiu.ltd/main '
12 >>> list = ['世界与你同在',' http://www.worldiwiu.ltd/main ']
13 >>> "网站名：{0[0]}，地址：{0[1]}".format(list) # 通过列表索引设置参数；“0”是必须的
14 '网站名：世界与你同在，地址：http://www.worldiwiu.ltd/main '关键字参数和默认值
像这样使用名称指定的参数称为关键字参数，只要有点是有足浴澄清各个参数的作用
>>>store(patient=’Mr.Brainsample’,hour=10,minute=20,day=13,month=5)
虽然这样做的输入量多些，但每个参数的作用清晰明了。另外，参数的顺序错了也没有关系，关键字参数最大的有点在于，可以指定默认值
1 def hello_1(getting,name):
2 print(‘{},{}!’.format(getting, name))
3 >>>hello_1(name=’world’, getting=’Hello’)
4 Hello,world!
5
6 def hello_1(name,getting):
7 print(‘{},{}!’.format(name, getting))
8 >>>hello_2(getting=’Hello’, name=’world’)
9 world,Hello!
10
11 def hello_3(getting=‘Hello’,name=‘world’):
12 print(‘{},{}!’.format(getting, name))
13 # 参数设置默认值
14 >>>hello_3()
15 Hello,world!
16 >>>hello_3('I love', 'you ')
17 I love,you !
18 >>>hello_3(name='xing')
19 Hello,xing!
20
21 def hello_4(name, getting='Hello', fuhao='!'):
22 print('{},{}{}'.format(getting, name, fuhao))
23 >>>hello_4('xing')
24 Hello,xing!
25 >>>hello_4('兴,今天过得好吗', getting='你好', fuhao='?')
26 你好,兴,今天过得好吗?收集参数
1 def print_params(*params):
2 print(params)
3 >>> print_params('Testing')
4 ('Testing',)
5 >>> print_params(1,2,3)
6 (1, 2, 3)
7
8 def print_params_2(title, *params):
9 print(title, end="")
10 print(params)
11 >>>print_params_2('Params:', 1, 2, 3)
12 Params:(1, 2,3)# *:收集余下的位置参数
13
14 def print_params_3(x, *y, z):
15 print(x, y, z)
16 >>>print_params_3(1, 2, 3, z=4)
17 1 (2, 3) 4
18 print_params_3(1, 2, 3, 4)
19 # 星号不会收集关键字参数
20 TypeError: print_params_3() missing 1 required keyword-only argument: 'z'
21
22 # 要收集关键字参数,可使用两个星号
23 def print_params_4(**params):
24 print(params)
25 >>>print_params_4(x=1, y=2, z=3)
26 {'x': 1, 'y': 2, 'z': 3}
27
28 def print_params_5(x, y, a, z=4, *pospar, **keypar):
29 print(x, y, z, a)
30 print(pospar)
31 print(keypar)
32 print_params_5(1, 2, 0, 3, 4, 5, 7, 6, foo=9, bar=8)
33 1 2 3 0
34 (5, 7, 6)
35 {'foo': 9, 'bar': 8}分配参数
1 def add(x, y):
2 return x + y
3 b=(2, 5)
4 print(add(*b)) # 显示: 7
5 # 这与前面的操作差不多是相反:不是收集参数,而是分配参数。这是通过在调用函数(而不是定义函数)时使用运算符*实现的
6 params = {'name': '兴', 'getting': '你好'}
7 hello_3(**params) # 你好,兴!转义字符
| 转义字符 |
描述 |
| \(在行尾时) |
续行符 |
| \\ |
反斜杠符号 |
| \' |
单引号 |
| \" |
双引号 |
| \a |
响铃 |
| \b |
退格(Backspace) |
| \e |
转义 |
| \000 |
空 |
| \n |
换行 |
| \v |
纵向制表符 |
| \t |
横向制表符 |
| \r |
回车 |
| \f |
换页 |
| \oyy |
八进制数，yy代表的字符，例如：\o12代表换行 |
| \xyy |
十六进制数，yy代表的字符，例如：\x0a代表换行 |
| \other |
其它的字符以普通格式输出 |
1 >>> print(r'I\nlove\nyou') # 加r之后，将输出原始字符串
2 I\nlove\nyou
3 >>> print('I\nlove\nyou')
4 I
5 love
6 you字符切片
1 >>> "hello word"[-0]
2 'h'
3 >>> "hello word"[0]
4 'h'
5 >>> "hello word"[2:5]
6 'llo'
7 >>> "hello word"[2:-1]
8 'llo wor'
9 >>> "I love you"[1]
10 ' ' # 空格也将会输出
11 >>> "I love you"[2:]
12 'love you'
13 >>> "I love you"[-3:]
14 'you'
15 >>> "I love you"[:-1]
16 'I love yo'
17 >>> "I love you"[:-0]
18 ''
19 >>> "I love you"[:0]
20 ''
21 >>> ["I","love","you"][1:]
22 ['love', 'you']
23 >>> ["I","love","you"][1:2]*3
24 ['love', 'love', 'love']
25 >>> type(["I","love","you"])
26 <class 'list'>
27 >>> (("I","love","you"))[1:]
28 ('love', 'you')
29 >>> "I love yuo I love you I love you"[2:15:3]
30 'leuIo'
31 >>> "I love yuo I love you I love you"[2::3]
32 'leuIo u vy'
33 # 2 :表示索引1； 15:表示索引2； 3 ：表示每隔三个输出一个字符
34 >>> "love" in ["I","love","yuo"]
35 True
36 # 表达式1 in 表达式 => 表达式1是否在表达式2中元组：( ) 列表：[ ] 字典：{ }（无序的，没有索引，不可切片）
1 >>> type(set()) # 定义空的集合
2 <class 'set'>
3 >>> {1,2,3,4,5,6,7} - {3,4} # 差集
4 {1, 2, 5, 6, 7}
5 >>> {1,2,3,4,5,6,7} & {3,4} # 交集
6 {3, 4}
7 >>> {1,2,3,4,5,6,7} | {3,4} # 并集
8 {1, 2, 3, 4, 5, 6, 7}位运算符
| & -> 与 |
| -> 或 |
^ -> 异或 |
- -> 取反 |
<< -> 左移动 |
>> -> 右移动 |
int str tuple （不可变）值类型 list set dict（可变）引用类型
成员资格运算符 in not in 测试该变量是否在该元组（列表、集合）中
相同运算符 is not is 比较变量是否是同一个对象
list：列表
| list01 = [1,2,3] list01.append(4) print("list01:", list01) list02 = list01 list03 = list01.copy() print("list02:", list02) list02[1] = 0 print("list03:", list03) print("list02:", list02) print("list01:", list01) list01.clear() list01[2:2] = [8] print("list03:", list03) print("list02:", list02) print("list01:", list01) |
list01: [1, 2, 3, 4]
list02: [1, 2, 3, 4]
list03: [1, 2, 3, 4] list02: [1, 0, 3, 4] list01: [1, 0, 3, 4] []
list03: [1, 2, 3, 4] list02: [1, 0, 8, 3, 4] list01: [1, 0, 8, 3, 4] |
append:用于将一个对象附加到列表末尾
=:这种复制（同一对象） copy：复制列表（两个不同对象）
clear：清空该列表 在列表中插入一个元素 |
列表函数
| len() |
返回列表的长度 |
| max() |
返回列表中最大值 |
| min() |
返回列表中最小值 |
| list() |
用于将元组转化为列表 |
列表方法
| append(object) |
用于将一个对象附加到列表末尾 |
  |
| clear() |
清空列表的内容 |
  |
| copy() |
复制列表（复制成两个不同对象） |
  |
| count(value) |
计算指定的元素在列表中出现了多少次 |
  |
| extend(list) |
能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提供给方法extend |
  |
| index(value) |
在列表中查找指定值第一次出现的索引 |
  |
| insert(index,object) |
用于将一个对象插入列表 |
  |
| pop([index]) |
从列表中删除一个元素（末尾为最后一个元素），并返回该元素 （pop是唯一既修改列表有返回一个非None值的列表方法；使用pop可实现一种常见的数据结构——栈（stack），后进先出（LIFO）） |
  |
| remove(value) |
用于删除第一个为指定值的元素 |
  |
| reverse() |
按相反的顺序排列列表中的元素（把列表元素反过来） |
  |
| sort() |
对列表进行升序排序 |
|
| sorted() |
对列表进行升序排序，或对字符串也可以进行排序操作 |
  |
tuple:元组（不可变）
元组函数
| len() |
返回元组长度 |
| max() |
返回元组最大值 |
| min() |
返回元组最小值 |
| tuple() |
用于将列表转换为元组 |
| sum() |
求元组中所有元素之和 |
dict:字典（无序）
格式：{key1 : value1, key2 : value2}
key：不可变的类型
1 >>> {'Q':'新月打击','W':'苍白之瀑','E':'月之降临','R':'月神冲刺'}['Q']
2 '新月打击'字典函数
| len(dict) |
计算字典元素个数 |
| str(dict) |
输出字典以可打印的字符串表示 |
| type(variable) |
返回输入的变量类型 |
字典方法
>>> dict = {} # 新建空字典
| clear() |
用于清除字典中的所有元素 |
||
| copy() |
用于复制字典 |
||
| get(key,[,d]) |
该方法中key是字典的键值，d是键值的默认值。若存在key就返回其值，否则返回d |
  |
|
| items() |
该方法使用字典中元素创建一个以(key,value)为一组的元组对象 |
  |
|
| keys() |
该方法使用字典中的键值来创建一个列表对象 |
  |
|
| values |
该方法使用字典中键值来创建一个列表对象 |
  |
|
| popitem() |
该方法用于删除字典中的随机一个元素 |
  |
|
| setdefault(key[,d]) |
该方法中key是字典的键值，d是键值的默认值。若key存在，就返回其值，否则返回d |
  |
|
| update(E) |
该方法中E是字典对象，由字典对象E来更新此字典 |
  |
|
| fromkeys() |
创建一个新字典，其中包括指定的键，且没个键对应的值都是None |
  |
|
| values() |
返回一个由字典中的值组成的字典视图 |
  |
先定义一个空字典
向字典中添加元素
输出字典视图 打印字典视图 |
迭代器与生成器
迭代是Python最强大的功能之一，是访问集合元素的一种方式
迭代器是一个可以记住遍历的位置的对象
迭代器对象从集合的第一元素开始访问，直到所有哦的元素被访问完结束。迭代器只能往前不会后退
迭代器有两个基本的方法：iter()和next()
StopItertion异常用于标识迭代的完成，防止出现无限 循环的情况，在__next__()方法中我们可以设置在完成指定循环次数后接触发StopItertion异常来结束迭代。
生成器：
在Python中，使用了yield的函数被称为生成器（generator）
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能永不迭代操作，更简单点理解生成器就是一个迭代器
在调用生成器运行的过程中，每次遇到yield时函数会暂停并保存当亲所有的运行信息，返回yield的值，并在下一次执行next()方法是从当前位置继续运行。
调用一个生成器函数，返回的是一个迭代器对象。
运算符的优先级
| 运算符说明 |
Python运算符 |
优先级 |
| 索引运算符 |
x[index]或x[index:index2[:index3]] |
18、19 |
| 属性访问 |
x.attrbute |
17 |
| 乘方 |
** |
16 |
| 按位取反 |
~ |
15 |
| 符号运算符 |
+或- |
14 |
| 乘、除 |
*、/、//、% |
13 |
| 加、减 |
+、- |
12 |
| 位移 |
>>、<< |
11 |
| 按位与 |
& |
10 |
| 按位异或 |
^ |
9 |
| 按位或 |
| |
8 |
| 比较运算符 |
==、!=、>、>=、<、<= |
7 |
| is运算符 |
is、is not |
6 |
| in运算符 |
in、not in |
5 |
| 逻辑非 |
not |
4 |
| 逻辑与 |
and |
3 |
| 逻辑或 |
or |
2 |
字符串
1 >>> a = "你好, %s, 你的房间号是%d。"
2 >>> b = ('张先生',102)
3 >>> a % b
4 '你好, 张先生, 你的房间号是102。'| %% |
百分号标记 |
| %c |
字符及其ASCII码 |
| %s |
字符串 |
| %d |
有符号整数（十进制） |
| %u |
无符号整数（十进制） |
| %o |
无符号整数（八进制） |
| %x |
无符号整数（十六进制） |
| %X |
无符号整数（十六进制大写字符） |
| %e |
浮点数字（科学计数法 ） |
| %E |
浮点数字（科学计数法，用E代替e） |
| %f |
浮点数字（用小数点符号） |
| %g |
浮点数字（根据值的大小采用%e或%f） |
| %G |
浮点数字（类似于%g） |
| %p |
指针（用于十六进制打印值的内存地址） |
| %n |
存储输出字符的数量放进参数列表下一个变量中 |
符号
| 符号 |
说明 |
| m.n |
m是显示的最小总宽度，n是小数点后的位数 |
| - |
用于左对齐 |
| + |
在正数前面显示加号（+） |
| # |
在八进制数面前显示‘0o’，在十六进制数前面显示'0x‘或者’0X' |
| 0 |
显示的数字前面填充‘0’取代空格 |
字符串方法、使用说明和案例
| 字符串方法 |
使用说明 |
案例 |
| capitalize() |
用于将字符串的第一个字母变成大写，其他字母变成小写 |
  |
| count(String,start,end) |
用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置 |
  |
| find(String,start,end) |
用于检测字符串中是否含子字符串。若含有子字符串，则返回开始的索引值；，否则返回 -1 还可以指定位置去查找子串 |
  |
| index(String,start,end) |
用于检测字符串中是否含子字符串。若含有，则返回开始索引值；否则会报一个异常 |
  |
| isalnum() |
用于检测字符串是否由汉字、字母和数字组成 |
  |
| join(sequence) |
将序列中的元素用指定的字符连接生成一个新的字符串 |
  |
| split() |
作用与join方法 相反 |
  |
| isalpha() |
用于检测字符串是否 只有字母和汉字组成 |
  |
| isdigit() |
用于检测字符串是否只由数字组成 |
  |
| lower() |
将字符全部转化为小写 |
  |
| swapcase() |
讲字符串大小写互换 |
  |
| upper() |
将字符全部转化为大写 |
  |
| min() |
字符串最小值 |
  |
| max() |
字符串最大值 |
  |
| len() |
计数字符串个数 |
  |
| title() |
“标题化”该字符串 |
  |
| replace(old,new[,max]) |
用于把字符串中的旧字符串替换成新的字符串 max: 表示替换不超过max次 |
  |
| translate() |
用法和replace方法相同，但不同的的是它只能替换一个字符 |
  |
| center() |
通过在两边添加填充字符（默认为空格）让字符串居中 |
  |
| strip() |
去除字符串开头和末尾的空格 |
  |
导包
| 导包 |
说明 |
| from math import * sqrt(9) |
第一种导包 后面用起来更简洁 |
| from math import sqrt,pow,floor |
第二种导包（可同时导入多个包） |
| import math math.sqrt(9) |
第三种导包 |
| import math as shuxue shuxue.sqrt(9) |
导包同时可以用(as)重命名 |
| from math as shuxue import * |
没有这种，会报错 |
| from math import pow as pf pf(2,3) pow(2,3) |
导入特定的函数并给它指定别名 |
赋值
| 赋值 |
说明 |
|
| 序列解包 |
||
| >>> x,y,z = 1,2,3 >>> print(x,y,z) 1 2 3 |
一起赋多个值 |
|
| >>> x,y,z = 1,2,3 >>> x,y = y,x >>> print(x,y,z) 2 1 3 |
两个变量值简易交换 |
|
  |
星号运算符（*）来收集多余的值，这样无需确保值和变量的个数相同 |
|
| 链式赋值 |
||
  |
同等效果 |
  |
  |
这样不是同一对象 |
常见语句
| 语句 |
说明 |
| pass |
空语句，主要为了保持结构的完整性。pass不做任何事情，一般用做占位语句 |
| continue |
跳出本次循环，执行下一次循环 |
| break |
终止循环 |
常用方法
| 函数 |
说明 |
案例 |
| range |
tart：计数从start开始。默认是从0开始。例如：range(5)等价于range(0,5) stop：计数到stop结束，但不包括stop。例如：range(0, 5)是[0, 1, 2, 3, 4]没有5 step：步长，默认为1。例如：range(0,5)等价于range(0,5,1) |
  |
| len |
方法返回对象（字符、列表、元组等）长度或项目个数。 |
|
| complex(real[,imag]) |
创建一个复数，其值为real + imag * j |
|
| dir([object]) |
返回object对象的属性名称列表。若没有指定参数object，则会返回现有的区域符号表（Loaal Symbol Table） |
|
| divmod(a,b) |
将a除以b的商与余数以元组类型返回，若a、b是整数或是长整数，返回值为(a/b,a%b), |
  |
| exal(expression[,globals[,locals]]) |
运行expression表达式。global定义全局命名空间(global namespace),locals定义局部命名空间(locals namespace)。若没有locals参数，则使用globals定义值。若没有globals与locals参数，则使用单元本身的命名空间 |
|
| exec string [in globals[,locals]] |
运行包含Python程序代码的字符串string，globals与locals分别定义全局命名空间与局部命名空间 |
|
| id(object) |
返回object对象的唯一识别码，此识别码为一整数 |
  |
| int(x[, radix]) |
x为数值/字符串,若是字符串，可以设置radix值。radix是进制的基底值，可以是[2,36]之间的整数或0.若radix是0，则Python会根据字符串值进行判断。radix是用来说明x是几进制数 |
  |
| max(s[,args...]) |
若只有一个参数，返回序数对象s中元素的最大值。如果有多个参数，返回最大的序数 |
  |
| min(s[,args...]) |
若只有一个参数，返回序数对象s中元素的最小值。若有多个参数，返回最小的序数 |
  |
| ord(c) |
返回单字符字符串c的ASCII或Unicode字符。若c是ASCII字符，ord()函数与chr()函数作用相反；若c是Unicode字符，ord()函数与unichr()函数作用相反 |
  |
| pow(x, y[, z]) |
若没有参数z返回xy，如果有z，则返回xy % z,y不能是负数 |
  |
| tuple(sequence) |
使用sequence来创建一个元组对象。若sequence本身就是一个元组，其值不变 |
  |
用户自定义函数
1 # def 自定义函数名（形参1，形参2，…）：
2 # 函数体
3 # （return 返回值）
4 # 参数：1.必须参数2.关键字参数3.默认参数
1 # 自定义函数
2 def add(x, y):
3 result = x+y
4 return result
5
6 z1 = add(3, 5) # 必须参数传值
7 z2 = add(y=5, x=3) # 关键字参数传值
8 print("z1 = ", z1, ",z2 = ", z2) # z1 = 8 ,z2 = 8__init__.py 文件的使用
1 import src.com.wx.ACM
2 # 欢迎来到IT决战空间，请展示您的代码效果了！
3 # src.com.wx.ACM_file.__init__.py
4 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5
6 import src.com.wx.PracticeTraining
7 # 欢迎来到IT决战空间，请展示您的代码效果了！
8 # src.com.wx.PracticeTraining_file.__init__.py
9 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
10
11 import init
12 # 欢迎来到IT决战空间，请展示您的代码效果了！
13 # src.com.wx.PracticeTraining.init_file.__init__.py
14 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~Python日期和时间
python中时间日期格式化符号
| %y |
两位数的年份表示（00-99） |
| %Y |
四位数的年份表示（000-9999） |
| %m |
月份（01-12） |
| %d |
月内中的一天（0-31） |
| %H |
24小时制小时数（0-23） |
| %I |
12小时制小时数（01-12） |
| %M |
分钟数（00=59） |
| %S |
秒（00-59） |
| %a |
本地简化星期名称 |
| %A |
本地完整星期名称 |
| %b |
本地简化的月份名称 |
| %B |
本地完整的月份名称 |
| %c |
本地相应的日期表示和时间表示 |
| %j |
年内的一天（001-366） |
| %p |
本地A.M.或P.M.的等价符 |
| %U |
一年中的星期数（00-53）星期天为星期的开始 |
| %w |
星期（0-6），星期天为星期的开始 |
| %W |
一年中的星期数（00-53）星期一为星期的开始 |
| %x |
本地相应的日期表示 |
| %X |
本地相应的时间表示 |
| %Z |
当前时区的名称 |
| %% |
%号本身 |
1 import time
2 import calendar
3 def Calendar():
4 year = int(time.strftime("%Y", time.localtime()))
5 month = int(time.strftime("%m", time.localtime()))
6 cal = calendar.month(year, month)
7 print(cal)
8 Calendar()
9 # July 2019
10 # Mo Tu We Th Fr Sa Su
11 # 1 2 3 4 5 6 7
12 # 8 9 10 11 12 13 14
13 # 15 16 17 18 19 20 21
14 # 22 23 24 25 26 27 28
15 # 29 30 31
16
17 print('北京时间:')
18 print(time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())) # 获取当前日期时间
19 # 北京时间:
20 # 2019-07-08 20:17:42
如有错误或不足，请留言，谢谢！
本文链接：https://www.cnblogs.com/AI-Star-Java/p/11718743.html
谢谢欣赏！关注一下！精彩不断！
原文出处：https://www.cnblogs.com/AI-Star-Java/p/11718743.html
来源：oschina
链接：https://my.oschina.net/u/4365260/blog/3249440