# 国际化输出
print("hello word")
print("word",end=" ") #不换行输出
#输入
# python3去除了raw_input 保留了input，将所有输入默认为字符串处理，并返回字符串类型。
a1 = input("input number: ")
#查看类型
print(a1,type(a1)) #
#判断a2的类型是否是int类型
a2=11
print(isinstance(a2,int)) #true
#保留4位小数
number=13.145924535
print("{:.6} s".format(number)) # 从整个数据截取（从左到右）
print(f"{round(number,4)} s".format(number)) #保留4位小数（四舍五入）
print(round(3.1415, 2)) #保留2位小数（四舍五入）
连接符"+"（数据类型为字符串时，或者一个为字符串，一个为其他类型是做的是连接符）
str1="hello"
str2="word"
print(str1+str2) #helloword
2、基本运算符
print(5 + 4) # 加法 9 print(4.3 - 2) # 减法 2.3 print(3 * 7 ) # 乘法 21 print( 2 / 4) # 除法，得到一个浮点数 0.5 print( 9 // 2 )# 除法，得到一个整数 4.5 print( 17 % 3) # 取余 2 print( 2 ** 5)# 乘方 32 print( abs(9 // 2 ))# 除法，得到一个整数 4.5 (向上取整) 43、常用的内置函数与模块 1、内置函数
abs(num) 求绝对值
max(num1,num2,…) 计算最大值
min(num1,num2,…) 计算最小值
round(num) 四舍五入 只保留整数部分
round(num,n) 四舍五入，指定保留小数位数
p = 3.147
print(round(p,2)) # 四舍五入，保留两位小数
pow(x,y) 求x的y次幂
eg：
p = 3.14623 print(round(p)) # 四舍五入到整数2、math模块函数 （使用前需先导入math模块–>import math
ceil(num) 向上取整 floor(num) 向下取整 sqrt(num) 开平方 log(x,base) 以base为基数，x的对数
eg：
# match模块 p1 = 3.1 print(math.ceil(p1)) # 向上取整3、使用前需先导入random模块–>import random
random.random() 指0到1范围之内的随机小数（注：[0,1)，包含0不包含1） random.choice(seq) 从一个序列中随机挑选随机数 random.uniform(x,y) 取x,y范围之内的随机小数（注：[x,y]，包含x和y） random.randint(x,y) 取x,y范围之内的随机整数（注：[x,y]，包含x和y） random.randrange(start,stop=None,step=1) 获取给定区间内的一个随机整数 [start,stop)，包含起始值，但不包含结束值 random.randrange(start,stop=None,step=2) 获取给定区间内的一个随机整数，步长step为2
eg：
print('取1到4内的随机整数（包含1但不包含4）=',random.randrange(1,4)) # 取1到4内的随机整数（包含1但不包含4）
print("取整=",math.trunc(3.4)) # 取整
扩展：截取小数第n位
def get_strip(number,n)->str:
str_number=str(number)
a,b=str_number.split(".")
b=(b+"0"*n)[:n]
return ".".join([a,b])
print(get_strip(123.4567, 3))
4、字符串的处理
转义字符
n 换行符，将光标位置移到下一行开头。 r 回车符，将光标位置移到本行开头。 t 水平制表符，也即 Tab 键，一般相当于四个空格。 a 蜂鸣器响铃。注意不是喇叭发声，现在的计算机很多都不带蜂鸣器了，所以响铃不一定有效。 b 退格（Backspace），将光标位置移到前一列。 \ 反斜线 ' 单引号 " 双引号 在字符串行尾的续行符，即一行未完，转到下一行继续写 :return:
# 前面加上r代表后面字符不转义
print("12345n6789")
print(r"12345n6789")
5、字串格式化
常用的格式化字符
%s 格式化字符串
%d 格式化整数
%f 格式化浮点数字，可指定小数点后的精度
:return:
方式一：
print("%s同学，今年%d岁"%("小美",20)) #小美同学，今年20岁
方式二：
# 这种更加灵活
print("{}同学，今年{}岁".format("小美", 20)) # 小美同学，今年20岁
方式三：
# 字面量格式
name="小美"
age=20
print(f"{name}同学，今年{age}岁") # 小美同学，今年20岁
6、正则表达式
findall(pattern, string, flags=0) 参数 pattern 为正则表达式, string 为待操作字符串, flags 为所用模式，函数作用为在待操作字符串中寻找所有匹配正则表达式的字串， 返回一个列表，如果没有匹配到任何子串，返回一个空列表。 match(pattern, string, flags=0) 使用指定正则去待操作字符串中寻找可以匹配的子串, 返回匹配上的第一个字串，并且不再继续找，需要注意的是 match 函数是从字符串开始处开始查找的，如果开始处不匹配，则不再继续寻找，返回值为 一个 SRE_Match (参见 第四小节 re 内置对象用法) 对象， 找不到时返回 None search(pattern, string, flags=0) 函数类似于 match，不同之处在于不限制正则表达式的开始匹配位置 . 匹配任意字符（不包括换行符） ^ 匹配开始位置，多行模式下匹配每一行的开始 $ 匹配结束位置，多行模式下匹配每一行的结束 * 匹配前一个元字符0到多次 + 匹配前一个元字符1到多次 ? 匹配前一个元字符0到1次 \ 转义字符，跟在其后的字符将失去作为特殊元字符的含义，例如\.只能匹配.，不能再匹配任意字符 [] 字符集，一个字符的集合，可匹配其中任意一个字符 A 匹配字符串开始位置，忽略多行模式 Z 匹配字符串结束位置，忽略多行模式 b 匹配位于单词开始或结束位置的空字符串 B 匹配不位于单词开始或结束位置的空字符串 d 匹配一个数字， 相当于 [0-9] D 匹配非数字,相当于 [^0-9] s 匹配任意空白字符， 相当于 [ tnrfv] S 匹配非空白字符，相当于 [^ tnrfv] w 匹配数字、字母、下划线中任意一个字符， 相当于 [a-zA-Z0-9_] W 匹配非数字、字母、下划线中的任意字符，相当于 [^a-zA-Z0-9_] I IGNORECASE， 忽略大小写的匹配模式, 样例如下 L LOCALE， 字符集本地化。这个功能是为了支持多语言版本的字符集使用环境的，比如在转义符w，在英文环境下，它代表[a-zA-Z0-9_]，即所以英文字符和数字。 如果在一个法语环境下使用，缺省设置下，不能匹配"é" 或 "ç"。加上这L选项和就可以匹配了。不过这个对于中文环境似乎没有什么用，它仍然不能匹配中文字符。 M MULTILINE，多行模式, 改变 ^ 和 $ 的行为findall
s = '''first lines econd line third line'''
print(re.findall("w+", s))
# output> ['first', 'line', 'second', 'line', 'third', 'line']
match
s = '''first line second line third line'''
m = re.match("w+"，s)
print(m)
# output> <_sre.SRE_Match object at 0x0000000002BCA8B8>
print(m.group(0))
# output> first
search
s = '''first line second line third line'''
print(re.search('iw+', s).group())
# output> irst
二、数据类型
1、数据类型
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）
str0 = 'Runoob'
print(str0) # 输出字符串 Runoob
print(str0[0:-1]) # 输出第一个到倒数第二个的所有字符 Runoo
print("abcd"[0:2]) #ab
print(str0[0]) # 输出字符串第一个字符 R
print(str0[2:5]) # 输出从第三个开始到第五个的字符 noo
print(str0[2:]) # 输出从第三个开始的后的所有字符 noob
print(str0 * 2) # 输出字符串两次，也可以写成 print (2 * str) RunoobRunoob
print(str0 + "TEST") # 连接字符串 RunoobTEST
print("1234n5678") #换行
print("1234\n5678") #转义
str1='abcdef'
print(str1[0:3])
# 字符串反转
a="123456789"
print("字符串反转:",a[::-1]) # 987654321
2、list【列表】
list 列表 元组使用小括号 ( )，列表使用方括号 [ ]。 截取的语法格式如下 变量[头下标:尾下标] 索引值以 0 为开始值，-1 为从末尾的开始位置。 len(list) 列表元素个数 max(list) 返回列表元素最大值 min(list) 返回列表元素最小值 list(seq) 将元组转换为列表 list.append(obj) 在列表末尾添加新的对象 list.count(obj) 统计某个元素在列表中出现的次数 list.pop([index=-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 list.remove(obj) 移除列表中某个值的第一个匹配项 list.reverse() 反向列表中元素 list.sort( key=None, reverse=False) 对原列表进行排序 list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 list.insert(index, obj) 将对象插入列表 list.clear() 清空列表 list.copy() 复制列表
eg:
list01 = [ 'abcd', 786 , 2.23, 'runoob', 70.2,[1,2,3]]
tinylist = [123, 'runoob']
print (list01) # 输出完整列表 ['abcd', 786, 2.23, 'runoob', 70.2, [1, 2, 3]]
print (list01[0]) # 输出列表第一个元素 abcd
print (list01[1:3]) # 从第二个开始输出到第三个元素 [786, 2.23]
print (list01[2:]) # 输出从第三个元素开始的所有元素 [2.23, 'runoob', 70.2, [1, 2, 3]
print (tinylist * 2) # 输出两次列表 [123, 'runoob', 123, 'runoob']
print (list01 + tinylist) # 连接列表 把两个列表连接起来
del list01[0]
print("删除第一个元素后的list",list01)
list01.append('Baidu')
print("删除第一个元素Baidu后的list", list01)
print(list)
print(type(list[0]))
print(list[0])
list1=['1','2','3',[1,2]]
print(list1[-1][1]) #2
#列表的反转
print(list1[::-1]) #[[1, 2], '3', '2', '1']
list1.reverse() #[[1, 2], '3', '2', '1']
遍历列表
for i in list1:
print(i)
3、tuple【元组】
Tuple（元组） 元组使用小括号 ( )，列表使用方括号 [ ]。 元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开。 元组内置函数 len(tuple) 计算元组元素个数。 max(tuple) 返回元组中元素最大值。 min(tuple) 返回元组中元素最小值。 tuple(iterable) 将可迭代系列转换为元组。
eg:
tuple = ('abcd', 786, 2.23, 'runoob', 70.2)
tinytuple = (123, 'runoob')
print(tuple) # 输出完整元组 ('abcd', 786, 2.23, 'runoob', 70.2)
print(tuple[0]) # 输出元组的第一个元素 abcd
print(tuple[1:3]) # 输出从第二个元素开始到第三个元素 (786, 2.23)
print(tuple[2:]) # 输出从第三个元素开始的所有元素 (2.23, 'runoob', 70.2)
print(tinytuple * 2) # 输出两次元组 (123, 'runoob', 123, 'runoob')
print(tuple + tinytuple) # 连接元组 穿件出一个新的元组 ('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')
元组的反转
print(tup1[::-1])
删除元组
tup = ('Google', 'Runoob', 1997, 2000)
print(tup)
del tup
for i in tup:
print(i)
4、set【集合】
Set（集合） 集合支持可变数据类型 集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。 基本功能是进行成员关系测试和删除重复元素。 add() 为集合添加元素 update() 给集合添加元素 clear() 移除集合中的所有元素 discard() 删除集合中指定的元素 pop() 随机移除元素 remove() 移除指定元素
sites = {'Google', 'Google','Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu',1}
print(sites) # 输出集合，重复的元素被自动去掉
# print(sites[1])
# 成员测试
if 'Runoob' in sites:
print('Runoob 在集合中')
else:
print('Runoob 不在集合中')
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a - b) # a 和 b 的差集
print(a | b) # a 和 b 的并集
print(a & b) # a 和 b 的交集
print(a ^ b) # a 和 b 中不同时存在的元素
# 1、添加元素
sites.add("a")
# 2、移除元素
sites.remove("a")
# 我们也可以设置随机删除集合中的一个元素，语法格式如下：
sites.pop()
# 4、清空集合
# sites.clear()
5、dictionary【字典】
len(dict) 计算字典元素个数，即键的总数。 str(dict) 输出字典，可以打印的字符串表示 type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。 dict.clear() 删除字典内所有元素 dict.copy() 返回一个字典的浅复制 dict.fromkeys() 创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值 dict.get(key, default=None) 返回指定键的值，如果键不在字典中返回 default 设置的默认值 key in dict 如果键在字典dict里返回true，否则返回false dict.items() 以列表返回一个视图对象 dict.keys() 返回一个视图对象 dict.update(dict2) 把字典dict2的键/值对更新到dict里 dict.values() 返回一个视图对象 pop(key[,default]) 删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。 否则，返回default值。 popitem()随机返回并删除字典中的最后一对键和值。
dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2] = "2 - 菜鸟工具"
tinydict = {'name': 'runoob', 'code': 1, 'site': 'www.runoob.com'}
print(dict)
print(dict['one']) # 输出键为 'one' 的值
print(dict[2]) # 输出键为 2 的值
print(tinydict) # 输出完整的字典
print(tinydict.keys()) # 输出所有键
print(tinydict.values()) # 输出所有值
info={"name":"mary","age":"12"}
#获取指定地点中的值
print(info["name"],info["age"]) #mary 12
print(info.get("name")) # mary
print(info) #{'name': 'mary', 'age': '12'}
info1=info.copy()
info.clear()
print(info1) # {'name': 'mary', 'age': '12'},复制的
for x,y in info1.items():
print(x,y) # name mary age 12
# 初始化字典
keys=["name","age","class","address"]
info2=dict.fromkeys(keys,"null")
print(info2) # {'name': 'null', 'age': 'null', 'class': 'null', 'address': 'null'}
keys1 = ("name", "age", "class", "address")
info3 = dict.fromkeys(keys1, "null")
print(info3) # {'name': 'null', 'age': 'null', 'class': 'null', 'address': 'null'}
keys2 = ("name", "age", "class", "address")
a=['1','2','3','4']
info4 = dict.fromkeys(keys2,"null")
print(info4) # {'name': 'null', 'age': 'null', 'class': 'null', 'address': 'null'}
将两个元组转换为字典
def to_dictionary(keys, values):
return {key:value for key, value in zip(keys, values)}
to_dict=to_dictionary(('a', 'b'), [1, 2]) # { a: 1, b: 2 } 传元组和列表都可以
遍历字典
case = {'method': 'get', 'url': '/cgi-bin/token',
'params': {'appid': 'wx74a8627810cfa308', 'secret': 'e40a02f9d79a8097df497e6aaf93ab80',
'grant_type': 'client_credential'}}
print(case['method'])
for key, value in (dict(case)).items():
if key in ['params', 'data', 'json']:
print(value)
2、数据类型之间相互的转换
# repr(x) #将对象x转换为表达式字符串 # eval(str) #用来计算在字符串中的有效Python表达式, 并返回一个对象 # tuple(s) #将序列s转换为一个元组 # list(s) #将序列s转换为一个列表 # set(s) #转换为可变集合 # dict(d) #创建一个字典d必须是一个(key, value)元组序列。 # frozenset(s) #转换为不可变集合 # chr(x) #将一个整数转换为一个字符 # ord(x) #将一个字符转换为它的整数值 # hex(x) #将一个整数转换为一个十六进制字符串 # oct(x) #将一个整数转换为一个八进制字符串1、基本数据类型的转换 int，float，str
x = int(1) # x 输出结果为 1
y = int(2.8) # y 输出结果为 2
z = int("3") # z 输出结果为 3
x = float(1) # x 输出结果为 1.0
y = float(2.8) # y 输出结果为 2.8
z = float("3") # z 输出结果为 3.0
w = float("4.2") # w 输出结果为 4.2
x = str("s1") # x 输出结果为 's1'
y = str(2) # y 输出结果为 '2'
z = str(3.0) # z 输出结果为 '3.0'
2、将字符串，集合，元组转换为列表list
a = "python" # 字符串
b = {1, 2, 3} # 集合
c = (1, 2, 3) # 元组
print(list(a)) # ["p", "y", "t", "h", "o", "n"]
print(list(b)) # [1, 2, 3]
print(list(c)) # [1, 2, 3]
3、将字符串，列表转换成集合set
a = "python" # 字符串
b = [1, 2, 1, 2] # 列表
c = {"a": 1, "b": 2} # 字典
d = (1, 2, 3, 4) # 元组
print(set(a)) # {"t", "o", "n", "p", "h", "y"}
print(set(b)) # {1, 2}
print(set(c)) # {"b", "a"}
print(set(d)) # {1, 2, 3, 4}
3、将字符串，类别，字典，集合转换为元组 tuple
a = "python" # 字符串
b = [1, 2, 1, 2] # 列表
c = {"a": 1, "b": 2} # 字典
d = {1, 2, 3, 4} # 集合
print(tuple(a)) # ("p", "y", "t", "h", "o", "n")
print(tuple(b)) # (1, 2, 1, 2)
print(tuple(c)) # ("a", "b")
print(tuple(d)) # (1, 2, 3, 4)
# 尝试将字典转换为元组时，只能得到由字典的key组成的元组，看来字典有些特殊
4、将元组，列表转换为内置函数dict
无法直接使用dict函数将列表，元组，集合转换成字典，这是由字典的结构决定的， 字典里的元素永远以key-value对的形式存在，key-value是一个映射关系， 知道key，便可以获得value，而其他3种容器类型数据不存在映射关系，因此无法转换。 dict函数有自己特殊的使用方法
my_dict = dict(a=1, b=2)
print(my_dict) #{"a": 1, "b": 2}
def to_dictionary(keys, values):
return {key:value for key, value in zip(keys, values)}
to_dictionary1(('a', 'b'), ['1',' 2']) # { a: 1, b: 2 } 传元组和列表都可以
三、循环控制语句
循环语句
while循环
while 判断条件(condition)：
执行语句(statements)……
def while_else():
number=1
while number < 5:
print(number, " 小于 5")
number = number + 1
else:
print(number, " 大于或等于 5")
for 语句
def for_in():
sites = ["Baidu", "Google", "Runoob", "Taobao"]
for site in sites:
if site == "Runoob":
print("菜鸟教程!")
break
print("循环数据 " + site)
else:
print("没有循环数据!")
print("完成循环!")
控制语句
def test1():
age = int(input("请输入你家狗狗的年龄: "))
print("")
if age <= 0:
print("你是在逗我吧!")
elif age == 1:
print("相当于 14 岁的人。")
elif age == 2:
print("相当于 22 岁的人。")
elif age > 2:
human = 22 + (age - 2) * 5
print("对应人类年龄: ", human)
### 退出提示
input("点击 enter 键退出")
四、函数
1、函数的定义
def 函数名（参数列表）:
函数体
无参数无返回
无参数有返回
有参数有返回
有参数无返回
参数* 把多个参数基于元组的方式进行传参
参数** 把多个参数基于字典的方式传参
2、参数的传参方式，方法的定义与使用
1、位置传参
方式1：
def fun(a,b,c):
print(a+b+c)
fun(10,20,30) #位置传参
方式二：
参数* 把多个参数基于元组的方式进行传参
参数** 把多个参数基于字典的方式传参
def fun(a,b,c):
print(a+b+c)
list=[1,2,3]
fun(*list) #将每个元素转换为位置传参传入创餐
2、关键字传参
方式一：
def fun(a,b,c):
print(a+b+c)
fun(a=1.1,b=1.2,c=1.3) #关键字传参
方式二：
参数* 把多个参数基于元组的方式进行传参
参数** 把多个参数基于字典的方式传参
def fun(a,b,c):
print(a+b+c)
dic={'a':1.2,'b':1.3,'c':1.4}
fun(**dic) #将每个字典，传入为关键字传参
3、静态方法，实例方法，类方法的定义与调用
class Students:
def __init__(self,name,age):
self.name=name #name称为局部变量，self.name实例属性 将局部变量赋值给实例属性
self.age=age
def people1(self): #实例方法
print(self.age)
print("实例方法被调用")
@staticmethod
def people2(): #静态方法
print("静态方法被调用")
@classmethod
def people3(cls): #类方法
print("类方法被调用")
def people(): #函数
pass
stu1=Students("张灿",10) #stu1实例类对象
# 方式1,通过对象调用#
stu1.people1()
stu1.people2()
stu1.people3()
# 方式2
Students.people1(stu1) #与这行代码功能相同 stu1.people1() 调用self自身的对象
# 方式3
Students("张灿",20).people1() # 等同于 stu1=Students("张灿",10)+stu1.people1()
#静态方法和类方法可以直接用类调用
Students.people2()
Students.people3()
4、私有属性的访问
class Students:
a=1
def __init__(self,name,age):
self.name=name #name称为局部变量，self.name实例属性 将局部变量赋值给实例属性
self.__age=age #私有属性，不希望在外部使用
def show(self):
print(self.name,self.__age)
def people(): #函数
pass
stu1=Students("张灿",10) #stu1实例类对象
# 方式1#
stu1.show()
#给实例属性赋值
stu1.name="张三"
#直接访问实例属性
print(stu1.name)
# print(dir(stu1))
print(stu1._Students__age) #可以通过_Students__age访问
print(Students.a)
2、匿名函数
# 所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
x = lambda a : a + 10
print(x(5))
# 可写函数说明 两个参数
sum = lambda arg1, arg2: arg1 + arg2
# 调用sum函数
print("相加后的值为 : ", sum(10, 20))
3、递归函数
def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n - 1)
factorial(1)
六：面向对象
1、类，方法，属性，对象的定义
# 类定义
class people:
# 定义基本属性
name = ''
age = 0
# 定义私有属性,私有属性在类外部无法直接进行访问
__weight = 0
# 定义构造方法
def __init__(self, name, age, weight):
self.name = name
self.age = age
self.__weight = weight
def speak(self):
print("%s 说: 我 %d 岁。" % (self.name, self.age))
print(f"{self.name} 说: 我 {self.age} 岁。")
# 实例化类
p = people('runoob', 10, 30)
p.speak()
2、继承
class Person(object):
def __init__(self,name,age):
self.name=name
self.age=age
def info(self):
print(self.name,self.age)
class student(Person):
def __init__(self,name,age,stu_id):
super().__init__(name,age)
self.stu_id=stu_id
def info(self):
super().info()
print(self.stu_id)
class teacher(Person):
def __init__(self,name,age,teacher_id):
super().__init__(name, age)
self.teacher_id = teacher_id
def info(self):
print(self.name,self.age,self.teacher_id)
if __name__ == '__main__':
stu=student("张三",10,101)
stu.info()
teacher("李四",20,201).info()
3、重写
class Student(object):
def __init__(self,name,age):
self.name=name
self.age=age
def __str__(self) -> str: #重写了objec中的str方法 一般会重写类的str方法，用于类的描述
return f'我叫{self.name}今年{self.age}岁'
if __name__ == '__main__':
stu = Student('张三', 20)
print(stu) #返回值的是一个字符串
print(type(stu)) #返回的是一个对象
4、多态
class Animal(object):
def eat(self):
print("动物会吃")
class Dog(Animal):
def eat(self):
print("狗会吃骨头")
class Cat(Animal):
def eat(self):
print("猫会吃鱼")
class Person():
def eat(self):
print("人吃五谷杂粮")
def fun(obj):
obj.eat()
fun(Cat())
fun(Dog())
print("_______________________________")
fun(Person()) #是否具有eat这个方法，不管继承
5、特殊方法
a=10
b=20
c=30
d=a.__add__(b)
print(d)
class Student(object):
def __init__(self,name):
self.name=name
def __add__(self, other): #对象的相加
return self.name+other.name
def __len__(self):
return len(self.name)
stu1=Student("张三")
stu2=Student("李四")
#执行两个对象相加
s=stu1+stu2
print(s)
#输出对象的长度
print(len(s))
6、new()方法和__init__方法之间的部分关系
class Person(object):
def __new__(cls, *args, **kwargs):
print('__new__被调用执行了，cls的id为{0}'.format(id(cls)))
obj=super().__new__(cls)
print('创建对象的id为{0}'.format(id(obj)))
def __init__(self,name,age):
print('__init__被调用执行了，self的id为:{0}'.format(id(self)))
self.name=name
self.age=age
print('object这个类的对象的id为:{0}'.format(id(object)))
print('Person这个类的对象的id为:{0}'.format(id(Person)))
p1=Person('张三',20)
print('p1这个类的对象的id为:{0}'.format(id(p1)))
本节通过案例介绍了__new__()方法和__init__方法之间的部分关系，总结如下： 1. __new__方法在__init__方法前执行，__new__方法执行后才返回实例对象，也就是说__new__方法执行前实例并未创建，构造方法中的参数self是__new__方法执行后传递过去的实例； 2. __new__方法的参数是由Python自动传递的，其参数包括创建实例时的“类名”对应类、以及创建创建实例传入的所有参数。7、特殊类
特殊类
class A:
pass
class B:
pass
class C(A,B):
def __init__(self,name,age):
self.name=name
self.age=age
x=C("张三",10)
print(x.__dict__) #查看对象的属性字典
print(C.__dict__) #类对象所属的字段
print(x.__class__) #输出对象所属的类
print(C.__bases__) #C类父类型的元素
print(C.__base__) #C类父类型的元素
print(C.__mro__) #查看类的继承结构
七、python时间格式化
ticks = time.time()
print ("当前时间戳为:", ticks)
localtime = time.localtime(time.time())
print ("本地时间为 :", localtime)
localtime = time.asctime( time.localtime(time.time()) )
print ("本地时间为 :", localtime)
# 格式化成2016-03-20 11:45:39形式
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
# 格式化成Sat Mar 28 22:24:24 2016形式
print(time.strftime("%a %b %d %H:%M:%S %Y", time.localtime()))
# 将格式字符串转换为时间戳
a = "Sat Mar 28 22:24:24 2016"
print(time.mktime(time.strptime(a, "%a %b %d %H:%M:%S %Y")))
filepath=f'log_{time.strftime("%Y-%m-%d %H-%M-%S", time.localtime())}'
with open(filepath,"w+",encoding="utf-8")as f1:
f1.write("123433")
print(datetime.datetime.now())
八、python文件的操作
file.read([size]) 从文件读取指定的字节数，如果未给定或为负则读取所有。 file.readline([size]) 读取整行，包括 "n" 字符。 file.write(str) 将字符串写入文件，返回的是写入的字符长度。 file.writelines(sequence) 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。 file.close() 关闭文件
with open("2022-03-06","r",encoding="utf-8")as f2:
# 一旦会有异常，会自动关闭文件
# print(f2.read()) #没有指定的话读取所以
print(f2.readline()) #读取整行 12344333
九、execl的操作
import openpyxl
def createExecl():
# 创建工作簿
wk=openpyxl.Workbook()
# 获取当前工作表
sheet=wk.active
# 写数据到单元格
sheet.cell(1,1).value="username" #第一行，第一列
sheet.cell(1, 2).value = "age" # 第一行，第二列
sheet.cell(1, 3).value = "class" # 第一行，第三列
wk.save("userinfo.xlsx")
# 读取execl表格
def readexlcl():
# 获取工作簿
wk=openpyxl.load_workbook("userinfo.xlsx")
# 获取工作表方式1
# sheet1=wk.get_sheet_by_name("Sheet")
# 获取工作表方式2
sheet2=wk["Sheet"]
# 获取单元格的坐标
print(sheet2.cell(1,1))
# 获取单元格的值
print(sheet2.cell(1,1).value)
# 获取工作簿的行数及列数
rows=sheet2.max_row
cols=sheet2.max_column
print(f"行数：{rows},列数：{cols}")
# 读取工作簿中所有数据
datas=[]
for row in range(1,rows+1):
for col in range(1,cols+1):
value=sheet2.cell(row,col).value
datas.append(value)
print(datas)
# 编辑execl文件
def editexecl(filepath):
# 加载工作簿
wk = openpyxl.load_workbook(filepath)
# 创建工作铺
mysheet=wk.create_sheet("mysheet1")
mysheet.cell(1,1).value="123"
wk.save(filepath)
if __name__ == '__main__':
# createExecl()
# readexlcl()
editexecl("userinfo.xlsx")
execl的读操作练习
import openpyxl
from openpyxl.utils import get_column_letter, column_index_from_string
wb=openpyxl.load_workbook("userinfo.xlsx")
# 输出所有表单
print(wb.sheetnames)
# 遍历表单
for sheet in wb:
print(sheet.title)
#创建表单
mysheet =wb.create_sheet("mysheet")
print(wb.sheetnames)
# 操作第三章表单
sheet3=wb.get_sheet_by_name("测绘师")
sheet33=wb["测绘师"]
# 获取当前活动的表单
ws=wb.active
print(ws) #输出的是一个表单对象
print(ws['A1']) #输出的是一个单元格的对象
print(ws['A1'].value)
c=ws['A1']
print('第row {} 的第 colume {} is {}'.format(c.row,c.column,c.value))
print('cell {} is {}'.format(c.coordinate,c.value))
print(ws.cell(row=1,column=1).value)
for i in range(1,ws.max_row+1):
print(ws.cell(row=i,column=1).value)
colB=ws['B']
ROW6=ws[2]
col_range=ws['B:C']
row_range=ws[1:2]
# print(col_range.value)
print("=================================")
for col in col_range:
for cell in col: #遍历B C列里面的单元格
print(cell.value)
print("=================================")
for row in ws.iter_rows(min_row=1,max_row=2,max_col=2): #获取第一行到第二行，第2列的数据
for cell in row:
print(cell.value)
print("=================================")
print(tuple(ws.rows))
print("=================================")
cell_range=ws['A1:C3']
for rowofcellobjcet in cell_range:
for cellobj in rowofcellobjcet:
print(cellobj.coordinate,cellobj.value)
print('---------------------end of row-----------------------')
print("{}行{}列".format(ws.max_row,ws.max_column))
#数字转换成字母
print(get_column_letter(2),get_column_letter(47),get_column_letter(900))
#字母转换成数字 A代表1 B代表2
print(column_index_from_string('A'),column_index_from_string('B'))
execl的写操作练习
import openpyxl
from openpyxl.utils import get_column_letter
wb=openpyxl.Workbook()
sheet=wb.active
print(sheet.title)
sheet.title='shee_name01'
wb.create_sheet(index=0,title='first sheet')
wb.create_sheet(index=1,title='two sheet')
print(wb.get_sheet_names())
wb.remove_sheet(wb.get_sheet_by_name('shee_name01'))
print(wb.get_sheet_names())
# wb.save("ceshi.xlsx")
wb.save('temp.xlsx')
wb1=openpyxl.Workbook()
sheet=wb1.active
sheet['A1']='hello word'
print(sheet['A1'].value)
