呕心沥血整理的python基础知识与练习题【你值得拥有！！！！】
2024-05-11 06:47:27
一、基础语法
1、输入与输出（hellw word）
# 国际化输出
print("hello word")
print("word",end=" ") #不换行输出#输入
# python3去除了raw_input 保留了input，将所有输入默认为字符串处理，并返回字符串类型。
a1 = input("input number: ") #查看类型
print(a1,type(a1)) # <class 'str'>#判断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) # 加法 9print(4.3 - 2) # 减法 2.3print(3 * 7 ) # 乘法 21print( 2 / 4) # 除法，得到一个浮点数 0.5print( 9 // 2 )# 除法，得到一个整数 4.5print( 17 % 3) # 取余 2print( 2 ** 5)# 乘方 32print( abs(9 // 2 ))# 除法，得到一个整数 4.5 (向上取整) 4
3、常用的内置函数与模块
1、内置函数
abs(num) 求绝对值
max(num1,num2,…) 计算最大值
min(num1,num2,…) 计算最小值
round(num) 四舍五入 只保留整数部分
round(num,n) 四舍五入，指定保留小数位数p = 3.147print(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("12345\n6789")print(r"12345\n6789")
5、字串格式化
常用的格式化字符%s 格式化字符串%d 格式化整数%f 格式化浮点数字，可指定小数点后的精度:return:
方式一：print("%s同学，今年%d岁"%("小美",20)) #小美同学，今年20岁方式二：# 这种更加灵活print("{}同学，今年{}岁".format("小美", 20)) # 小美同学，今年20岁方式三：# 字面量格式name="小美"age=20print(f"{name}同学，今年{age}岁") # 小美同学，今年20岁
6、正则表达式
findall(pattern, string, flags=0)
参数 pattern 为正则表达式, string 为待操作字符串, flags 为所用模式，函数作用为在待操作字符串中寻找所有匹配正则表达式的字串，
返回一个列表，如果没有匹配到任何子串，返回一个空列表。match(pattern, string, flags=0)
使用指定正则去待操作字符串中寻找可以匹配的子串, 返回匹配上的第一个字串，并且不再继续找，需要注意的是 match
函数是从字符串开始处开始查找的，如果开始处不匹配，则不再继续寻找，返回值为 一个 SRE_Match (参见 第四小节 re 内置对象用法) 对象，
找不到时返回 Nonesearch(pattern, string, flags=0)
函数类似于 match，不同之处在于不限制正则表达式的开始匹配位置. 匹配任意字符（不包括换行符）
^ 匹配开始位置，多行模式下匹配每一行的开始
$ 匹配结束位置，多行模式下匹配每一行的结束
* 匹配前一个元字符0到多次
+ 匹配前一个元字符1到多次
? 匹配前一个元字符0到1次
\\ 转义字符，跟在其后的字符将失去作为特殊元字符的含义，例如\\.只能匹配.，不能再匹配任意字符
[] 字符集，一个字符的集合，可匹配其中任意一个字符
\A 匹配字符串开始位置，忽略多行模式
\Z 匹配字符串结束位置，忽略多行模式
\b 匹配位于单词开始或结束位置的空字符串
\B 匹配不位于单词开始或结束位置的空字符串
\d 匹配一个数字， 相当于 [0-9]
\D 匹配非数字,相当于 [^0-9]
\s 匹配任意空白字符， 相当于 [ \t\n\r\f\v]
\S 匹配非空白字符，相当于 [^ \t\n\r\f\v]
\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('i\w+', s).group())
# output> irst
二、数据类型
1、数据类型
不可变数据（3 个）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）
1、string【字符串】
str0 = 'Runoob'print(str0) # 输出字符串 Runoobprint(str0[0:-1]) # 输出第一个到倒数第二个的所有字符 Runooprint("abcd"[0:2]) #abprint(str0[0]) # 输出字符串第一个字符 Rprint(str0[2:5]) # 输出从第三个开始到第五个的字符 nooprint(str0[2:]) # 输出从第三个开始的后的所有字符 noobprint(str0 * 2) # 输出字符串两次，也可以写成 print (2 * str) RunoobRunoobprint(str0 + "TEST") # 连接字符串 RunoobTESTprint("1234\n5678") #换行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]) # 输出列表第一个元素 abcdprint (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 tupfor 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")) # maryprint(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=1while number < 5:print(number, " 小于 5")number = number + 1else:print(number, " 大于或等于 5")for 语句
def for_in():sites = ["Baidu", "Google", "Runoob", "Taobao"]for site in sites:if site == "Runoob":print("菜鸟教程!")breakprint("循环数据 " + 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) * 5print("对应人类年龄: ", 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=agedef people1(self): #实例方法print(self.age)print("实例方法被调用")@staticmethoddef people2(): #静态方法print("静态方法被调用")@classmethoddef people3(cls): #类方法print("类方法被调用")def people(): #函数passstu1=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=1def __init__(self,name,age):self.name=name #name称为局部变量，self.name实例属性 将局部变量赋值给实例属性self.__age=age #私有属性，不希望在外部使用def show(self):print(self.name,self.__age)def people(): #函数passstu1=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 1else:return n * factorial(n - 1)factorial(1)六：面向对象
1、类，方法，属性，对象的定义
# 类定义
class people:# 定义基本属性name = ''age = 0# 定义私有属性,私有属性在类外部无法直接进行访问__weight = 0# 定义构造方法def __init__(self, name, age, weight):self.name = nameself.age = ageself.__weight = weightdef 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=nameself.age=agedef 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_iddef 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_iddef 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=nameself.age=agedef __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=30d=a.__add__(b)
print(d)class Student(object):def __init__(self,name):self.name=namedef __add__(self, other): #对象的相加return self.name+other.namedef __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=nameself.age=ageprint('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:passclass B:passclass C(A,B):def __init__(self,name,age):self.name=nameself.age=agex=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 openpyxldef 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")# 获取工作表方式2sheet2=wk["Sheet"]# 获取单元格的坐标print(sheet2.cell(1,1))# 获取单元格的值print(sheet2.cell(1,1).value)# 获取工作簿的行数及列数rows=sheet2.max_rowcols=sheet2.max_columnprint(f"行数：{rows},列数：{cols}")# 读取工作簿中所有数据datas=[]for row in range(1,rows+1):for col in range(1,cols+1):value=sheet2.cell(row,col).valuedatas.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_stringwb=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.activeprint(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_letterwb=openpyxl.Workbook()
sheet=wb.activeprint(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.activesheet['A1']='hello word'
print(sheet['A1'].value)
呕心沥血整理的python基础知识与练习题【你值得拥有！！！！】相关推荐
- python基础知识学习笔记（2）
python基础知识学习笔记(2) 整理一下python基础知识,以防忘记 文章目录 python基础知识学习笔记(2) python简洁的一行代码 python简洁的一行代码 1.交换两个变量 # ...
- python基础知识思维导图总结
今天给同学用思维导图整理了python基础知识,供大家复习参考学习,希望每天都有进步. 最后增加了列表推导式的案例和使用,学会了一定很香! 鸡汤几点: 没有目标永远不知道方向在哪? 不去尝试永远不知道 ...
- python基础知识整理-python爬虫基础知识点整理
首先爬虫是什么? 网络爬虫(又被称为网页蜘蛛,网络机器人,在FOAF社区中间,更经常的称为网页追逐者),是一种按照一定的规则,自动的抓取万维网信息的程序或者脚本. 根据我的经验,要学习Python爬虫 ...
- python基础知识500题_python爬虫基础知识点整理
更多编程教程请到:菜鸟教程 https://www.piaodoo.com/ 友情链接: 高州阳光论坛https://www.hnthzk.com/ 人人影视http://www.sfkyty.com ...
- 整理了100道关于Python3基础知识的练习题，记得收藏
100道关于Python3基础知识的练习题 实例1.数字组合 实例2.个税计算 实例3.完全平方数 实例4.这天第几天 实例5.三数排序 实例6.斐波那契数列 实例7.copy 实例8.九九乘法表 实 ...
- Python基础知识整理(含思维导图)
✔️ Python基础知识 Python内置对象 数字 int ,float ,complex 实例:123,3.14 python 数字类型 整数 二进制 0,1 必须0b开头 八进制 0-7 必须 ...
- python打印古诗_python打印古诗_python教程：利用python基础知识取出对应诗句
<python教程:利用python基础知识取出对应诗句>由[张国维博客]于2020年05月09日整理发布! 当今科技蓬勃发展的今天,我们学习一门编程语言是很有必要的.随着人工智能行业的兴 ...
- python爬虫数据可视化_python 爬虫与数据可视化--python基础知识
摘要:偶然机会接触到python语音,感觉语法简单.功能强大,刚好朋友分享了一个网课<python 爬虫与数据可视化>,于是在工作与闲暇时间学习起来,并做如下课程笔记整理,整体大概分为4个 ...
- Python 基础知识学习笔记——OpenCV（1）
Python 基础知识学习笔记--OpenCV(1) OpenCV是一个开源的跨平台计算机视觉和机器学习软件库,它轻量而且高效,被广泛的使用. 整理一下OpenCV学习笔记,以防忘记. 文章目录 Py ...
最新文章
- Spring-boot+Vue = Fame 写blog的一次小结
- 什么是 AIDL 以及如何使用
- SQL Server 2008 批量插入数据时报错
- leetode题库5438--制作 m 束花所需的最少天数
- 图像处理、语音处理的应用及前沿技术_自主知识产权的2微米级3D视觉相机应用于高精度和高反光物体的缺陷检测...
- 比较两个字符串相同的个数,并输出
- pandas CSV读取编码问题记录
- 单片机c语言编程定时,单片机C语言编程定时器的几种表达方式
- 微信小程序 【给图片加上删除图标】
- r语言如何计算t分布临界值_R语言系列第四期：R语言单样本双样本差异性检验...
- JS 判断元素父子关系
- 0xc0000225无法进系统_win10系统出现0xc0000225无法进入系统的恢复方法
- win7无法连接打印机拒绝访问_win7无法连接打印机拒绝访问|WinXP访问Win10打印机被拒绝怎么办？...
- sock 中的send和recv
- Buffon's Needle
- 管好自己，但行好事，不渡他人
- 2020中国高校计算机大赛网络技术挑战赛,中国高校计算机大赛－网络技术挑战赛的新跨越...
- 许键树：华为云视频直播在各细分场景的体验指标优化实践
- UR5机械臂正向运动学
- 设置RGui的背景颜色和字体