计算机由两部分组成:硬件和软件
文本分为两种,一种叫做纯文本,还有一种叫做富文本
常见的字符集
乱码 编写程序时,如果发现程序代码出现乱码的情况,就需要检查字符集是否正确
计算机智能识别二进制编码,所以任何的语言在交由计算机执行时,必须先转换为机器码,也就是像print(‘hello‘)必须要转换为类似1010101这样的机器码
根据转换时机的不同,语言分成两大类
name = "吴鹏"
# 普通的输出变量
print(name)
# 输出变量不换行
# print(name, end=‘‘)
# 第二种格式化输出变量
a = ‘吴鹏‘
b = 20
print("a:{},b:{}".format(a, b))
# 输入变量
data = input("请输入你的名字:") # 可以作为一个变量然后返回打印输出
print(data)
a = "你是头猪%s" % "顾成龙" + ",是的吧"
print(a)
# 如果传入多个参数,那么%后面加上括号,参数以逗号隔开
b = "你是%s,他是%s" % ("猪", "牛")
print(b)
# 表示保留3位字符
c = "需要几个字母:%.3s" % "牛鼻的人啊"
print(c)
# 表示浮点数长度保留3位,四舍五入
d = "需要几个字母:%.3f" % 123.45678
print(d)
# 表示长度控制在5位,如果是三位整数,会在前面补全为0
e = "需要几个字母:%.5d" % 123.45678
print(e)
# 使用格式化参数
name = "顾成龙"
f = f"你是{name}吗"
print(f)
# 使用format进行格式化输出
g = "你是{}吗?".format("猪")
print(g)
布尔值实际上也属于整型,True就相当于1,False就相当于0,是可以跟数字进行运算的
所谓的类型转换,将一个类型的对象转换为其他对象
类型转换不是改变对象本身的类型,而是将对象的值转换为新的对象
类型转换的四个函数 int() float() str() bool()
首先引入datatime
import datetime
# 获取当前时间
time = datetime.datetime.now()
print(time)
# 获取一个指定日期
this_time = datetime.datetime(2019, 10, 1, 12, 3, 30)
print(this_time)
# 日期转字符串
d = time.strftime("%Y-%m-%d %H:%M:%S")
print(d)
# 字符串转日期
s = "2017-10-1 10:30:59"
m = time.strptime(s, "%Y-%m-%d %H:%M:%S")
print(m)
在python运算中有优先级
运算符的优先级可以根据优先级的表格来查询
在表格中为止越靠下的运算符优先级越高,优先级越高的越优先计算,如果优先级一样则自左向右计算
一般在开发中遇到优先级不清楚,基本使用小括号来改变运算顺序(基本上小括号是通用)
# 可以存放任意的数据类型
a=[1,2,3,"wupeng",[1,2,3]]
获取指定位置的值,如:print(a[3])
如果使用的索引超过了最大的范围,会抛出异常
# 列表的切片
做切片操作时,总会返回一个新的列表,不会影响原来的列表
print(a[0:3]) 包括0,不包括3
print(a[-4:-1]) 包括-4,不包括-1 倒数第四个开始-倒数第一个结束(不包括) 取值:2,3,"wupeng"
# 通用操作
可以将两个列表拼接为一个列表
mylist=[1,2,3]+[4,5,6]
print(mylist)
也可以将列表重复几次
mylist=[1,2,3]*3
print(mylist)
使用in和not in来检查元素是否存在于列表中
len() 获取类表中元素的个数
min() 获取列表中的最小值
max() 获取列表中的最大值
index() 可以获取指定元素在列表中第一次的索引,第一个参数是元素,第二个参数表示查找的起始位置,第三个参数表示查找的结束位置
append() 表示在原有数据上追加
insert(a,b) 向列表的指定位置插入一个元素,第一个参数表示插入的位置,第二个参数表示插入的参数
extend(list) 需要一个类表作为参数,会将该序列中的元素添加到当前列表中
clear() 清空序列
pop() 根据索引删除并返回被删除的元素
remove() 删除指定的元素,如果相同值的元素有多个,只会删除第一个
reverse() 用来反转列表
sort() 用来对列表中的元素进行排序,默认是升序排列,如果需要降序排列,则需要传递一个reverse=True作为参数
# 指定位置添加元素
a.insert(2,4) 在列表的下标为2的位置后面添加4
# 通过索引修改元素
a=[1,2,3,4,5]
a[0]=2
print(a)
# 通过切片来修改列表,在给切片进行赋值时,只能使用序列
mylist[0:2]=[1,2,3] 打印出来的结果会将索引为0,1的数值换掉
# 函数(range)
range()是一个函数,可以用来生成一个自然数的序列
该函数需要三个参数
1. 起始位置
2. 结束位置
3. 步长(可以省略,默认是1(常用也是默认值))
序列是python中最基本的一种数据结构
序列用于保存一组有序的数据,所有的数据在序列当中都有一个唯一的位置(索引),并且序列汇总的数据会按照添加的顺序来分配索引
系列的分类
# 元祖的解包
my_tuple=(1,2,3,4,5)
a,b,c,d,f=my_tuple
a,b=b,a
print(a,b)
# 在对一个元祖进行解包时,变量的数量必须和元祖中的元素数量一致,也可以在变量前边添加一个*,这样变量将会获取元素中所有剩余的资源(剩余的资源会产生在添加*的变量,并且以列表存在)
my_tuple=(1,2,3,4,5)
a,b,c,*d=my_tuple
a,b=b,a
print(a,b,c,d) # d的值为[4,5]
a={"username":"吴鹏","age":18}
print(a["username"]) # 能够得到值:吴鹏
# 使用dict()函数来创建字典
# 每一个参数都是一个键值对,参数名就是键,参数名就是值(这种方式创建的字典,key都是字符串)
d=dict(name="wupeng",age=18)
print(d)
# 也可以将一个包含有双值子序列的序列转换为字典,双值序列,序列中只有两个值,子序列,如果序列中的元素也是序列,那么我们成这个元素为子序列
d = dict([(4, 2), (1, 3)])
print(d) # {4:2,1:3}
# len() 可以获取字典中键值对的个数
# in 检查字典中是否包含指定键
# not in 检查字典中是否不包含指定的键
# get() 通过get获取键值对的值
d=dict(username="吴鹏",age=18)
print(d.get("username"))
# 修改字典
d=dict(username="吴鹏",age=18)
d[‘username‘]="吴磊"
print(d.get(‘username‘))
# 字典添加键值对
# 使用setdefault()想字典中添加key-value,如果key已经存在于字典中,则返回key的值,不会对字典做任何操作,如果key已经存在于字典中,则返回key的值,不会对字典做任何操作
d=dict(username="吴鹏",age=18)
d.setdefault(‘username1‘,‘吴娟‘)
print(d)
# 将其他字典添加到当前字典update方法
d=dict(username="吴鹏",age=18)
d2={‘class‘:123,‘huiyi‘:333}
d.update(d2)
print(d)
# 集合是一种无序集,是一组键的集合,不存储值
# 在集合中,重复的键是补被允许的,集合可以用于去除重复值
# 集合也可以进行数学集合运算
# 应用:把一个列表变成集合,就自动去重了
a={1,2,3,4,5,6}
b={4,5,6,7,8,9}
print(a-b) 表示集合的差集:1,2,3
print(a|b) 表示集合的并集:1,2,3,4,5,6,7,8,9
print(a&b) 表示集合交集:4,5,6
print(a^b) 表示集合的对称差:1,2,3,7,8,9
b = b‘\xe9\x80\x86\xe7\x81\xab‘
string = str(b, ‘utf-8‘)
print(string)
# bytes转字符串方式二
b = b‘\xe9\x80\x86\xe7\x81\xab‘
string = b.decode() # 第一参数默认utf8，第二参数默认strict
print(string)
# bytes转字符串方式三
b = b‘\xe9\x80\x86\xe7\x81haha\xab‘
string = b.decode(‘utf-8‘, ‘ignore‘) # 忽略非法字符，用strict会抛出异常
print(string)
# bytes转字符串方式四
b = b‘\xe9\x80\x86\xe7\x81haha\xab‘
string = b.decode(‘utf-8‘, ‘replace‘) # 用？取代非法字符
print(string)
# 字符串转bytes方式一
str1 = ‘逆火‘
b = bytes(str1, encoding=‘utf-8‘)
print(b)
# 字符串转bytes方式二
b = str1.encode(‘utf-8‘)
print(b)
# 输出结果
逆火
逆火
逆haha
逆?haha?
b‘\xe9\x80\x86\xe7\x81\xab‘
b‘\xe9\x80\x86\xe7\x81\xab‘
if 判断条件:
执行语句
if 判断条件:
执行语句
elif 判断条件:
执行语句
else:
执行语句
如果需要在某一个条件里面做二次判断,那么可以使用if嵌套,也就是if结构里面在包含一个或多个if结构
if 条件1:
if 条件2:
else:
else:
# for循环是可以依次得到序列循环中的每个元素,并依次处理
"""
for 循环指定次数:for i in range(初始值,结束值,步长)
"""
for i in range(0,10,2):
print("打印十次")
# 对列、元祖、集合遍历
# 列
list = [1, 2, 3, 4, 5, 6]
# 元祖
list1 = (1, 2, 3, 4, 5)
# 字典
list2 = {"username": "吴鹏", "age": 18}
# 集合
list3 = {1, 2, 3, 4, "wupeng"}
# 遍历列表
for i in list:
print(i)
# 遍历元祖
for m in list1:
print(m)
# 遍历字典
for n,k in list2.items():
print(n,k)
# 遍历集合
for p in list3:
print(p)
# 求100以内的和
# 求1-100的和
sum = 0
for i in range(0, 101):
sum += i
print(sum)
# 求列表中的最大值
# 求列表中的最大值,思路:先设定下标为0是最大的,循环遍历列表的数,如果下标0<下标1,那么最大值=下标1
a = [1, 2, 234, 456, 678]
maxx = a[0]
for i in range(0, len(a) - 1):
if a[0] < a[i + 1]:
maxx = a[i + 1]
print(maxx)
while循环和for循环不同的是,它的停止条件是个人自己设定的
while 判断条件:
执行语句
判断条件和if语句是相同的,那么什么时候用while呢,在你确定满足条件而不确定需要的循环次数时,那么while是最好的选择
# 循环操作20年每年的每个月递增20元,统计每年每月的金额数
i = 0
sum = 0
while i <= 20:
print("这是第", i, "年")
j=1
while j<=12:
sum+=20
print("第",i,"年,","第",j,"月,","需要交纳",sum,"元")
j+=1
i+=1
print(sum)
如果循环中的循环条件永远为真,且没有break关键字进行终端,那么就形成一个无线循环,无线循环也被成为死循环.一般情况会通过一个条件结束死循环
# 计算所有的奇数之和(使用while)
num = 0
sum = 0
while num <= 100:
if num % 2 != 0:
print(num)
sum += num
num += 1
print("所有奇数和:{}".format(sum))
# 计算所有的奇数之和(使用for... in ...)
sum = 0
# 与while的区别:num不需要定义变量为0
for num in range(101):
if num % 2 != 0:
print(num)
sum += num
num += 1
print("所有的奇数之和:{}".format(sum))
# 使用for动态打印矩形
# 外层循环控制行,内层循环控制列
num = input("请输入边数:")
num = int(num)
for i in range(num - 1):
for j in range(num):
print("*", end="")
print("")
# 动态打印正三角
num = input("请输入三角的边数:")
num = int(num)
for i in range(num):
for j in range(i + 1):
print("*", end="")
print("")
# 乘法表
# 1*1=1
# 1*2=2 2*2=4
# 1*3=3 2*3=6 3*3=9
num = int(input("请输入乘法表边数(行跟列)"))
for i in range(num + 1):
for j in range(i + 1):
print("{}*{}={}".format(j + 1, i + 1, (j + 1) * (i + 1)), end=" ")
print("")
# 电脑随机一个0 - 100的数, 将用户输入的跟电脑随机的数字对比, 满分是100分, 猜错口扣10分, 分数为0, 停止程序.
import random
score = 100
# randint(0,100) 包含0跟100
a = random.randint(0, 100)
count = 0
while True:
num = int(input("请输入第{}个:".format(count + 1)))
if num > a:
print("猜大了")
elif num < a:
print("猜小了")
else:
print("猜对了")
count += 1
if count == score / 10:
break
print("分已经全没,重启程序")
"""
猜数字游戏, 电脑随机产生一个0 - 100的整数, 用户在控制台输入一个整数, 将用户输入的和电脑产生的进行对比:
如果用户猜大了, 就提示猜大了, 猜小了, 就提示猜小了, 猜对了就恭喜答对了
满分是100分，猜错一次就减10分，
当分数为0的时候，停止程序。
"""
import random
content = random.randint(0, 100)
count = 0
score = 100
while True:
if score == 0:
print("您的分数已经归为0,再见")
break
num = int(input("请输入第{}个数:".format(count + 1)))
if num > content:
print("您猜大了")
score -= 10
print("当前分数为:{}".format(score))
elif num < content:
print("您猜小了")
score -= 10
print("当前分数为:{}".format(score))
else:
print("恭喜你,猜对了,当前分数为:{}".format(score))
break
count += 1
"""
随机加减乘除运算, 一共出10题, 电脑随机产生2个0 - 100的整数, 进行随机加减乘除法计算
然后用户输入计算结果, 判断用户输入的是否正确, 回答正确就加十分, 错误就不加分, 10题全对就是100分
"""
import random
score = 0
test = 0
sum = 0
while True:
if test == 10:
break
num1 = random.randint(0, 100)
num2 = random.randint(0, 100)
t = random.randint(0, 3)
if t == 0:
print("请回答第{}题:{}+{}=?".format((test + 1), num1, num2))
sum = num1 + num2
elif t == 1:
print("请回答第{}题:{}-{}=?".format((test + 1), num1, num2))
sum = num1 - num2
elif t == 2:
print("请回答第{}题:{}*{}=?".format((test + 1), num1, num2))
sum = num1 * num2
else:
print("请回答第{}题:{}//{}=?".format((test + 1), num1, num2))
sum = num1 // num2
user = int(input("请输入结果:"))
if user == sum:
score += 10
print("回答正确加10分,当前分数为:{}".format(score))
else:
print("回答错误减10分,当前分数为:{}".format(score))
print("当前总分为:{}".format(score))
test += 1
# 创建一个10个长度整数列表, 列表中的10个元素, 使用随机数赋值, 范围0 - 100, 然后找出列表中的最大值
import random
list = []
for i in range(10):
list.append(random.randint(0, 100))
for j in range(len(list)):
max = list[0]
if max < list[j]:
max = list[j]
print(list[i], end=" ")
print("最大值为max:{}".format(max))
# 冒泡排序
num = [51, 12, 55, 29, 18, 18, 18, 18, 55, 295, 5, 29]
for i in range(len(num)):
# 选出最大去掉一个
for j in range(len(num) - 1 - i):
if num[j] > num[j + 1]:
t = num[j]
num[j] = num[j + 1]
num[j + 1] = t
print(num)
"""
从26个字母中，随机选出4个不重复的字母并且把4个字母，添加到一个列表中
用户在控制台输入4个字母，将用户输入的也添加到一个列表中
然后将电脑的和用户的进行对比
"""
import random
# 从26个字母中，随机选出4个不重复的字母
def getChar():
c1 = [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘, ‘f‘, ‘g‘, ‘h‘, ‘i‘, ‘j‘, ‘k‘, ‘l‘, ‘m‘, ‘n‘, ‘o‘, ‘p‘, ‘q‘, ‘r‘, ‘s‘, ‘t‘, ‘u‘, ‘v‘,
‘w‘, ‘x‘, ‘y‘, ‘z‘]
c2 = []
for i in range(4):
index = random.randint(0, len(c1) - 1)
c2.append(c1[index])
del c1[index]
print(c2)
return c2
# 检查用户输入是否正确的
def check(charList, user):
# 第一个下标保存猜对了几个，
# 第二个下标保存位置对了几个
result = [0, 0]
for i in range(len(charList)):
if user[i] in charList:
result[0] += 1
if user[i] == charList[i]:
result[1] += 1
print("猜对了{}个，位置对了{}个。".format(result[0], result[1]))
return result
print("猜字母游戏开始了。")
charList = getChar()
while True:
str = input("请输入四个字母,退出输入exit")
if str == "exit":
break
user = []
for s in range(4):
user.append(str[s])
print(user)
res = check(charList, user)
if res[1] == 4:
print("恭喜，全部猜对了")
break
print("游戏结束")
# 函数就是可以把我们要执行的代码放到一起,需要执行的时候直接调用就可以.
# 函数的命名规则
def name(x):
s=x*x
return s
def 是个关键字
name 是函数命名
x 输入一个参数
return 返回一个值
# 必填参数和缺省参数的结合
# 必填参数a,缺省参数b
def test1(a, b=3):
print(a, b)
test1(0)
# 0 3
test1(0, 1) # 0 1
注:声明函数时,当同时存在必填参数和缺省参数,形参的顺序必须是(必填参数,缺省参数),不能缺省参数在前
# 可变参数
def test2(num, num2=2, *args):
print(num, num2, args)
test2(1) # 1 2 ()
test2(1, 3) # 1 3 ()
test2(1, 3, 3, 3, 3, 3, 3) # 1 3 (3, 3, 3, 3, 3)
test2(1, *(2, 3, 4, 5)) # 1 2 (3, 4, 5)
test2(1, *[2, 3, 4, 5]) # 1 2 (3, 4, 5)
注:args是一个元祖类型,可变参数可不穿,也可以传很多个值,在元祖or列表前面加一个*,代表将里面的每个元素都独立出来,单独作为一个形参传进去
# 关键字参数
def test3(a, b=2, **kwargs):
print(a, b, kwargs)
test3(1) # 1 2 {}
test3(1, 3) # 1 3 {}
test3(1, **{"key": "value"}) # 1 2 {‘key‘: ‘value‘}
test3(1, 3, **{"key": "value", "key1": "val", "key2": ‘val2‘}) # 1 3 {‘key‘: ‘value‘, ‘key1‘: ‘val‘, ‘key2‘: ‘val2‘}
test3(1, name="yy", key="value") # 1 2 {‘name‘: ‘yy‘, ‘key‘: ‘value‘}
test3(1, 3, name="yy", key="value") # 1 3 {‘name‘: ‘yy‘, ‘key‘: ‘value‘}
test3(1, name="yy", key="value",b=222222) # 1 222222 {‘name‘: ‘yy‘, ‘key‘: ‘value‘}
# test3(1, 22222,name="yy", key="value",b=222222) # 会报错，因为第二个值已经传给缺省参数b了
# 注:
# kwargs是一个字典类型,关键字传参数可传可不传
# 如果传dict需要在前面加上**,表示将这个dict的所有key-value当成独立的关键字参数,（变成key=value）传入到kwargs，而修改kwargs不会影响原来的dict
# 不用dict的话也可以直接 key=value 的写法，如果和缺省参数重名，若前面没有传值的话，会当成缺省参数传值；若有的话会直接报错声明函数时,缺省参数不可以放在可变参数后面
# 四种参数类型都有的函数
def test4(a, b=2, *args, **kwargs):
print(a, b, args, kwargs)
test4(1) # 1 2 () {}
test4(1, 1) # 1 1 () {}
test4(1, *(1, 2, 3, 3, 4,)) # 1 1 (2, 3, 3, 4) {}
test4(1, *(1, 2, 3, 3, 4,), cc=123, c=123) # 1 1 (2, 3, 3, 4) {‘cc‘: 123, ‘c‘: 123}
lists = ["a", "b"]
dicts = {"key": 123}
test4(1, *lists, **dicts) # 1 a (‘b‘,) {‘key‘: 123}
作用域是指变量生效的区域
变量定义在函数内部,所以作用域就是函数内部,函数外部无法访问
在python中一共有两种作用域
变量的查找
当我们使用变量时,会优先在当前作用域中寻找该变量,如果有则使用,如果没有则继续去上一级作用域中寻找,如果有就使用,如果依然没有则继续去上一级作用域中寻找,以此类推,知道找到全局作用域,依然没有找到则会抛出异常.
# 在函数中为变量赋值时,默认都是为局部变量赋值,如果希望在函数内部修改全局变量,则需要使用global关键字来声明变量,然后在进行修改
def fun():
global a
a = 10
print(a)
fun()
print(a) # 上面使用global a,已经将a变成全局,然后a修改为10,所以这里也就打印10
def un1():
a = 1
scope = locals()
print(scope)
un1()
递归简单理解就是自己去引用自己,递归式函数,在函数中自己调用自己.
递归是解决问题的一种方式,和循环很像,整体思想是将一个大问题分解为一个个的小问题,直到问题无法分解时,在去解决问题
def fun(n):
# 基线条件
if n == 1:
return 1
# 递归条件
return n * fun(n - 1)
print(fun(3))
# 计算n**i
# 10**5=10*10**4
# ...
# 10**1=10
def power(n, i):
if i == 1:
return n
return n * power(n, (i - 1))
print(power(10, 5))
接收函数作为参数,或者将函数作为返回值的函数是高阶函数
def fun1(i):
if i > 5:
return True
else:
return False
def fun2(i):
if i % 2 == 0:
return True
else:
return False
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def method(func, lst):
new_list = []
for n in lst:
if func(n):
new_list.append(n)
return new_list
print(method(fun1, l))
# filter()可以从序列中过滤出符合条件的元素,保存到一个新的序列中
参数:
1. 函数,根据该函数来过滤序列(可迭代的结构)
2. 需要过滤的序列(可迭代的结构)
返回值:过滤后的新序列(可迭代的结构)
def fun(i):
return i % 3 == 0
l = [12, 3, 4, 5, 6, 7, 8, 9]
r = filter(fun, l)
print(list(r))
# fun是作为参数传递进filter()函数中,而fun实际上只有一个作用,就是作为filter()参数,filter调用完毕以后,fn4就已经没用
# 匿名函数lambda函数表达式
# lambda函数表达式专门用来创建一些简单的函数,是函数创建的有一种方式
# 语法:lambda 参数列表:返回值
l = [12, 3, 4, 5, 6, 7, 8, 9]
r = filter(lambda i: i % 3 == 0, l)
print(list(r))
# map()函数可以对可迭代对象中的所有元素做指定的操作,然后将其添加到一个新的对象中返回
l = [12, 3, 4, 5, 6, 7, 8, 9]
r = map(lambda i: i * 2, l)
print(tuple(r))
# sort() 该方法用来对列表中的元素进行排序,默认是直接比较列表中的元素大小,在sort可以接收一个关键字参数key,key需要一个函数作为参数,每次都会以列表中的一个元素作为参数来调用函数,并且使用函数的返回值来比较元素的大小
l = ["a", "bbb", "cc", "dddd"]
l.sort(key=len)
print(l)
# sorted() 这个函数和sort()的用法基本一致,但是sorted()可以对任意的序列进行排序,并且使用sorted()排序不会影响原来的对象,而是返回一个新对象
# 将函数作为返回值返回,也是一种高阶函数,这种高阶函数我们也称为闭包,通过闭包可以创建一些只有当前函数能访问的变量,可以将一些私有的数据藏到闭包中
def fun():
def fun1():
print("你是猪")
return fun1
fun()()
# 文件读取
# 读取txt中的数据
file = open(‘th.txt‘, ‘r‘)
result = file.read()
print(result)
file.close()
# 读取txt中的第一行数据(需要获取第二行在读取一次)
file = open(‘th.txt‘, ‘r‘)
result1 = file.readline()
print(result1)
file.close()
# 循环读取txt中的所有行数据
file = open(‘th.txt‘, ‘r‘)
result1 = file.readlines()
for i in result1:
print(i)
file.close()
# 文件写入
# 如果文件存在,就重新写入;如果文件不存在则新建一个文件并写入
file = open(‘th.txt‘, ‘w‘)
file.write("你不是很聪明")
print(file)
file.close()
# 文件追加写入
# 如果文件存在,就重新写入;如果文件不存在则新建一个文件并写入
file = open(‘th.txt‘, ‘a‘) # a表示append 追加写入
file.write("你不是很聪明")
print(file)
file.close()
# 文件读取二进制文件
# 如果文件存在,就重新写入;如果文件不存在则新建一个文件并写入
file = open(‘th.txt‘, ‘rb‘) # a表示append 追加写入
result = file.read()
print(result)
# 将读取文件封装成方法(使用with...as的作用就是打开后,最终自动关闭)
def read_txt(fileName):
filepath = "C:/Users/17327/PycharmProjects/yunhe/data/" + fileName
arr = []
with open(filepath, "r", encoding="utf-8") as file:
datas = file.readlines()
for data in datas:
arr.append(tuple(data.strip().split(",")))
return arr
# seek()可以修改当前读取的位置,需要两个参数
1. 第一个是要切换到的位置
2. 计算位置方式,可选值
1. 0 从头计算,默认值
2. 1 从当前位置计算
3. 2 从最后位置开始计算
# tell()方法用来查看当前读取的位置
# 读取文件的其他方法
# 引入os
os.listdir() 获取指定目录的目录结构,需要一个路径作为参数,会获取到该路径下的目录结构,默认路径为.,当前目录,该方法会返回一个列表,目录中的每一个文件的名字都是列表中的一个元素
os.getcwd() 获取当前所在的目录
os.chdir("c:/") 切换到当前所在目录
os.mkdir("aaa") 在当前目录下创建一个名字为aa的目录
os.rmdir("abc") 删除目录
os.remove("aa.txt") 删除文件
os.rename("旧名字","新名字") 可以对一个文件进行重命名,也可以用来移动一个文件
class Dog(object):
tpyes = "阿拉斯加" # 类变量
# 初始化方法
def __init__(self, name, age, sex):
# 实例化变量(属性)
self.name = name
self.age = age
self.sex = sex
# 定义普通方法
def eat(self):
print("狗仔吃饭")
def run(self):
print("狗仔跑步")
class Dog(object):
types = "宠物" # 类变量
# 初始化方法,也就是在对象创建的时候就会调用这个方法
def __init__(self, name, age, sex): # self表示当前对象
# 实例化变量(属性)
self.name = name
self.age = age
self.sex = sex # self.__sex=sex 表示私有化(要想获取,需要在类内部定义一个方法调用self.__sex)
# 定义普通方法
def eat(self, speed):
print(self.name + "狗仔吃饭" + "特别快" + speed)
def run(self):
print("狗仔跑步")
# 实例化对象
dog = Dog(‘阿拉斯加‘, ‘18‘, ‘雄‘)
dog.name = ‘萨摩耶‘
print(dog.name)
dog.eat("3m/s")
# 创建一个父类
class Animal(object):
def __init__(self,color):
self.color=color
def eat(self):
print("动物在吃")
def run(self):
print("动物在跑")
# 创建一个子类继承
from animal import Animal
import all
class Cat(Animal):
pass
class Dog(Animal):
def __init__(self, name, age, color):
super().__init__(color) # 调用父类的color,dog同样继承
self.name = name
self.age = age
def eat(self):
print("狗仔吃饭")
def run(self):
print("狗仔跑步")
an1 = Animal("绿色")
cat = Cat("黄色")
cat.eat()
dog = Dog("阿拉斯加", 19, "黄色")
dog.eat()
print(dog.color)
all.feed(an1) # 模拟多态实现动物在吃
all.feed(cat) # 模拟多态实现猫在吃,如果没有eat方法,调用父类方法
all.feed(dog) # 模拟多态实现狗在吃
class Animal:
def __init__(self, name, age, nom):
self.name = name
self.age = age
self.nom = nom
def run(self):
print("你确实会跑")
class Dog(Animal):
def __init__(self, name, age, nom, sex):
super().__init__(name, age, nom)
self.sex = sex
def run(self):
print(self.name, self.age, self.nom, self.sex)
d = Dog("wupeng", 12, 23, 45)
d.run()
# 需要安装Tushare,Tushare是一个免费、开源的ptyhon财经数据接口包,主要实现对股票等金融数据从数据采集、清洗加工到数据存储的过程,能够为金融分析人员提供快速、整洁和多样的便于分析的数据. pip install tushare
代码实现:
import time
import tushare
import datetime
class GetShare(object):
def __init__(self, code):
self.dateNow = tushare.get_realtime_quotes(code)
datetime.datetime.now()
def getShare(self):
# 股票名
name = self.dateNow.loc[0][0]
# 当前价格
price = float(self.dateNow.loc[0][3])
# 最高价
high = self.dateNow.loc[0][4]
# 最低价
low = self.dateNow.loc[0][5]
# 成交量
volumn = self.dateNow.loc[0][8]
# 成交额
amount = self.dateNow.loc[0][9]
# 开盘价
openToday = self.dateNow.loc[0][1]
# 收盘价
pre_close = self.dateNow.loc[0][2]
# # 时间
# timee = self.dateNow.loc[0][30]
return print("股票名:", name, "\t", "当前价格:", price, "\t", "最高价:", high, "\t", "最低价:", low, "\t", "成交量:", volumn,
"\t", "成交额:",
amount, "\t", "开盘价:", openToday, "\t", "收盘价:", pre_close, "\t", "当前时间:",
datetime.datetime.now(), "\t")
ge = GetShare("300026")
ge1 = GetShare("600577")
ge2 = GetShare("300152")
list1 = [ge, ge1, ge2]
while True:
for i in list1:
i.getShare()
print("")
ge.getShare()
print(
"\n---------------------------------------------------------------------------------------------"
"---------------------------------------------------------------------------------------------")
time.sleep(10)
均是Exception的子类
以下所有异常都是OSError的子类
a=[1,2,3,0,1,54,3,"a",2,1]
for i in a:
try:
if 3/i==1:
print("有东西")
else:
print("东西没用")
except:
print("此处出现异常")
常见的错误和异常
# try-except-else的用法
a = [1, 2, 3, 0, 1, 54, 3, "a", 2, 1]
for i in a:
try:
if 3 / i == 1:
print("有东西")
else:
print("东西没用")
except:
print("此处出现异常")
else:
print("异常没有抛出,是正确的") # 在没有走except抛出异常而是走try的时候,会执行else的内容
# try-except-else-finally的用法
a = [1, 2, 3, 0, 1, 54, 3, "a", 2, 1]
for i in a:
try:
if 3 / i == 1:
print("有东西")
else:
print("东西没用")
except:
print("此处出现异常")
else:
print("异常没有抛出,是正确的") # 在没有走except抛出异常而是走try的时候,会执行else的内容
finally:
print("最终结束内容") # 有异常也输出,没有异常也输出
a="123456"
if len(a)<8:
ex=Exception("不能小于8位")
raise ex
else:
print("可以进行操作")
常见的电子邮件协议有SMTP、POP3、IMAP4,隶属于TCP/IP协议,默认状态下,分别通过TCP协议端口25、110和143连接
import smtplib
from email.mime.text import MIMEText
msg_from = "17327767735@163.com"
pwd = "123453A" # 授权密码
to = "1059457506@qq.com"
subject = "这是我要发送的邮件"
content = "你家着火了"
# 构造邮件
msg = MIMEText(content) # msg邮件对象
msg["Subject"] = subject
msg["From"] = msg_from
msg["To"] = to
# 发送邮件
ss = smtplib.SMTP_SSL("smtp.163.com", 465)
ss.login(msg_from, pwd)
ss.sendmail(msg_from, to, msg.as_string())
进程就是一段程序的执行过程,它是一个具有一定独立功能的程序关于某个数据集合的一次运动活动,它是操作系统动态执行的基本单元
进程有3种状态
进程的实现原理
先创建进程在进行提交,然后就绪,就绪如果等待i/o时,阻塞,条件满足后执行,最终在退出。
Python的标准库提供了两个模块:_thread和threading,_thread是低级模块,threading是高级模块,对_thread进行了封装,绝大多数情况下,我们只需要使用threading这个高级模块,启动一个线程就是把一个函数传入并创建Thread实例,然后调用start()开始执行
# 主线程和子线程
import threading
import time
def run(name):
print(name, "线程开始执行了")
time.sleep(5)
# target指向一个目标
# 程序执行时,程序本身就是一个线程,叫主线程,手动创建的线程叫子线程
# 主线程的执行中不会等子线程执行完毕就会直接执行后面的代码
# 创建子线程
t1 = threading.Thread(target=run, args=("t1",))
t2 = threading.Thread(target=run, args=("t2",))
t1.start()
t2.start()
t1.join() # 等待子线程执行完毕之后在执行主线程内容(会等待5s中之后执行print)
t2.join()
print("完毕了")
# 线程锁(作用是为了防止线程在执行过程中出现跳出执行发生错乱)
import threading
import time
lock = threading.Lock() # 创建了线程锁
num = 100
# 这边方法传值,那么threading.Thread()需要传入args=(参数,)
def run():
lock.acquire() # 设置锁
global num
num = num - 1
print("线程", num, "执行了,目前的值为:", num)
lock.release() # 释放锁
for i in range(100):
td = threading.Thread(target=run)
td.start()
python安装mysql模块包 pip install pymysql
import pymysql
# 打开数据库连接, 主机地址 端口号3306 用户名root 密码 数据库名
db = pymysql.Connect(host=‘localhost‘, port=3306, user=‘root‘, passwd=‘bb961202‘, db=‘animal‘, charset=‘utf8‘)
# 创建一个游标对象,用来操作数据库
cursor = db.cursor()
print(db)
import pymysql
# 打开数据库连接, 主机地址 端口号3306 用户名root 密码 数据库名
db = pymysql.Connect(host=‘localhost‘, port=3306, user=‘root‘, passwd=‘bb961202‘, db=‘animal‘, charset=‘utf8‘)
# 创建一个游标对象,用来操作数据库
cursor = db.cursor()
# 新建表
sql = ‘create table persions(name varchar(20),age int(10))‘
cursor.execute(sql)
print(db)
# 需要注意的是在做python新增的时候需要commit,并且字符集数据库要跟pymysql.Connect()中的charset=‘utf8‘一致
import pymysql
# 打开数据库连接, 主机地址 端口号3306 用户名root 密码 数据库名
db = pymysql.Connect(host=‘localhost‘, port=3306, user=‘root‘, passwd=‘bb961202‘, db=‘animal‘, charset=‘utf8‘)
# 创建一个游标对象,用来操作数据库
cursor = db.cursor()
# 新建表
# sql = "create table persions7(name varchar(20),age int(10))"
sql = ‘insert into dog(name,age)values("球球",12)‘
cursor.execute(sql)
db.commit()
print(db)
import pymysql
# 打开数据库连接, 主机地址 端口号3306 用户名root 密码 数据库名
db = pymysql.Connect(host=‘localhost‘, port=3306, user=‘root‘, passwd=‘bb961202‘, db=‘animal‘, charset=‘utf8‘)
# 创建一个游标对象,用来操作数据库
cursor = db.cursor()
# 新建表
# sql = "create table persions7(name varchar(20),age int(10))"
sql = ‘select * from dog‘
cursor.execute(sql)
# data = cursor.fetchone() # 获取单个对象(也就是单条数据)
# print(data)
data1 = cursor.fetchall() # 获取多个对象(也就是多条数据)
list = []
for i in data1:
list.append(i)
print(list) # 或者一个列表内包含元祖的数据
import pymysql
# 打开数据库连接, 主机地址 端口号3306 用户名root 密码 数据库名
db = pymysql.Connect(host=‘localhost‘, port=3306, user=‘root‘, passwd=‘bb961202‘, db=‘animal‘, charset=‘utf8‘)
# 创建一个游标对象,用来操作数据库
cursor = db.cursor()
# 新建表
# sql = "create table persions7(name varchar(20),age int(10))"
sql = ‘update dog set name="憨怂" where name="憨比"‘
sq2=‘delete from dog where name="憨比1"‘
cursor.execute(sql)
cursor.execute(sq2)
db.commit() # 做修改时,需要提交
db.close() # 执行任意增删改查最好关闭数据库
import pymysql
# 打开数据库连接, 主机地址 端口号3306 用户名root 密码 数据库名
db = pymysql.Connect(host=‘localhost‘, port=3306, user=‘root‘, passwd=‘bb961202‘, db=‘animal‘, charset=‘utf8‘)
# 创建一个游标对象,用来操作数据库
cursor = db.cursor()
# 新建表
# sql = "create table persions7(name varchar(20),age int(10))"
sql = ‘update dog set name="憨怂" where name="憨比"‘
sq2 = ‘delete from dog where name="憨比1"‘
try:
cursor.execute(sql)
cursor.execute(sq2)
db.commit() # 做修改时,需要提交事务,事务中的操作就是要么都提交,要么都不提交
except:
db.rollback() # 回滚所有操作都不提交
print()
db.close() # 执行任意增删改查最好关闭数据库
后续补充...
原文：https://blog.51cto.com/u_15291895/2983431