微信公众号：大数据左右手
专注于大数据技术，人工智能和编程语言
个人既可码代码也可以码文字。欢迎转发与关注
Python入门小进阶
接着上一篇目继续学习python
上一篇链接：半天轻轻松松入门python
本篇主要学习内容
-
函数
-
文件操作
-
文件夹操作
-
面向对象
-
异常
函数
## 定义函数 标识符由字母、下划线和数字组成，且数字不能开头
'''
def 函数名():
代码
'''
## 调用函数
'''
函数名()
'''
## 例子（九九乘法表）
##定义一个名字叫print_99的函数
def print_99():
i = 1
while i <= 9 :
j = 1
while j <= i :
print("%d*%d=%d\t" % (j,i,i*j),end="")
j += 1
i += 1
print("")
## 调用函数
# print_99()
## 1.有传参有返回值的函数
## 无返回值
def add_num_no_return(a,b):
print("a+b=%d"%(a+b))
add_num_no_return(100,200) # a+b=300
## 有返回值
def add_num_return(a,b):
return a+b
add_num_return(100,200) # 300
## 2.缺省参数
def print_info1(name, age = 25 ):
print("name:%s"%name)
print("age:%d"%age)
## 使用 注意：带有默认值的参数一定要位于参数列表的最后面(除非自己指定)
# print_info('wangbo') # name:wangbo age:25
# print_info('wangbo',26) # name:wangbo age:26
# print_info(26,'wangbo') # 报错
# print_info(age=26,name='wangbo') # 指定后可以正常使用
## 3.不定长参数
def print_info2(*names):
print(names)
# print_info2('zhang','wang','li','zhao') # ('zhang', 'wang', 'li', 'zhao')
## 4.拆包 注意：* 与 ** 的区别
def print_info3(*names,**people):
print(names)
print(people)
a=('zhang','wang','li','zhao')
b={'name':'wangbo','age':'25'}
# print_info3(*a,**b) # ('zhang', 'wang', 'li', 'zhao') {'name': 'wangbo', 'age': '25'}
## 5.引用传参
def add_self(a):
a+=a
print(a)
# add_self(a) # ('zhang', 'wang', 'li', 'zhao', 'zhang', 'wang', 'li', 'zhao')
## 6.函数返回多个值
def print_info4():
a=10
b=20
c=30
return a,b,c
# print_info4() # (10, 20, 30)
文件操作
## 使用open函数，可以打开一个已经存在的文件，或者创建一个新文件open(文件名，访问模式)
'''
r: 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。如果文件不存在会崩溃。
w: 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a: 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。
也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
rb: 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
wb：以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。
也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
r+：打开一个文件用于读写。文件指针将会放在文件的开头。
w+：打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a+：打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。
如果该文件不存在，创建新文件用于读写。
rb+：以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
wb+：以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
ab+：以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
'''
## 打开文件open
# w = open('../data/test.txt', 'w')
# w.write('hello world, 欢迎你来到这里')
## 读数据(read)
r = open('../data/test.txt', 'r')
## 使用read(num)可以从文件中读取数据，num表示要从文件中读取的数据的长度（单位是字节），如果没有传入num，那么就表示读取文件中所有的数据
# content1 = r.read()
# print(content1)
## readlines可以按照行的方式把整个文件中的内容进行一次性读取，并且返回的是一个列表，其中每一行的数据为一个元素
# content2 = r.readlines()
# print(content2)
## readline 每次就读一行
# content3 = r.readline()
# print(content3)
## 关闭文件close
r.close()
参数说明列表
| 参数 | 解释 |
|---|---|
| r | 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。如果文件不存在会崩溃 |
| w | 打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a | 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| rb | 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。 |
| wb | 以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| ab | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。 |
| r+ | 打开一个文件用于读写。文件指针将会放在文件的开头。 |
| w+ | 打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| a+ | 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。 |
| rb+ | 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。 |
| wb+ | 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。 |
| ab+ | 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 |
简单的文件复制
## 简单的文件复制
old_file=open('../data/test.txt','r')
new_file=open('../data/test_temp.txt','w')
## 读取要复制的文件，写到新文件中去
new_file.write(old_file.read())
new_content = open('../data/test_temp.txt','r').readlines()
print(new_content)
old_file.close()
new_file.close()
文件读写定位
## 在读写文件的过程中，如果想知道当前的位置，可以使用tell()来获取
# tell = open("../data/test.txt", "r")
# str = tell.read(3)
# print("读取的数据是 : ", str)
## 查找当前位置
# position = tell.tell()
# print("当前文件位置 : ", position)
# tell.close()
## 如果在读写文件的过程中，需要从另外一个位置进行操作的话，可以使用seek()
## seek(offset, from)有2个参数 offset:偏移量 from:方向
# 0:表示文件开头
# 1:表示当前位置
# 2:表示文件末尾
seek = open("../data/test.txt", "r")
seek.seek(3,0) # 从文件开头第三位开始读
str1 = seek.read()
print("读取的数据是 : ", str1) # 结果：lo world, 欢迎你来到这里
seek.close()
文件的重命名与删除
import os
## os模块中的rename()可以完成对文件的重命名操作
## rename(需要修改的文件名, 新的文件名)
# os.rename('../data/test_temp.txt','../data/test_rename.txt')
## os模块中的remove()可以完成对文件的删除操作
# os.remove('../data/test_rename.txt')
文件夹的相关操作
import os
## 1. 创建文件夹
# os.mkdir('../data/test_doc')
## 2. 创建多层目录
# os.makedirs('../data/test_doc/a/b/c')
## 3. 获取当前目录
os.getcwd() # '/opt/module/jupyter/wangbo/python'
## 4. 改变默认目录
# os.chdir("../../")
# os.getcwd() # '/opt/module/jupyter'
## 5. 获取目录列表，包含文件和目录
# os.listdir("./") # ['notebook.log', '.ipynb_checkpoints', 'wangbo']
## 6. 删除文件夹
# os.rmdir('/opt/module/jupyter/wangbo/data/test_doc/a/b/c')
## 7. 删除多层目录
import shutil
# shutil.rmtree('/opt/module/jupyter/wangbo/data/test_doc')
## 恢复到之前的路径下
# os.chdir("/opt/module/jupyter/wangbo/python")
# os.getcwd()
案例：批量修改文件名
import os
## 先创建一批文件
# os.mkdir("../data/test_doc")
## #进入test_doc目录
# os.chdir("../data/test_doc")
# i = 1
# while i <= 10 :
# open("机器学习-%d.docx" %i,"w")
# i += 1
# print("创建完毕!")
## 修改：把机器学习-X.docx 修改为 神经网络-X.docx
## 1. 得到文件下所有文件的文件名
file_names=os.listdir()
## 2. 遍历并修改
for file_name in file_names:
print(file_name)
new_name= "我在学-"+file_name
os.rename(file_name,new_name)
面向对象
## 创建对象
class People(object):
#初始化函数，用来完成一些默认的设定
def __init__(self):
print('我被初始化加载了....')
def __del__(self):
print("python解释器开始回收%s" % self)
def __str__(self):
return 'welcome people'
# 方法：吃
def eat(self):
print('那个人在吃东西....')
# 方法：喝
def drink(self):
print("那个人在喝水...")
## 创建一个对象，并用变量zhangsan来保存它的引用
zhangsan = People()
## 添加属性
zhangsan.sex='男'
zhangsan.age='88'
## 调用对象方法
zhangsan.eat() # 那个人在吃东西....
zhangsan.drink() # 那个人在喝水...
## 调用属性
print(zhangsan.age)
## 总结
## 理解self
# 某个对象调用其方法时，Python解释器会把这个对象作为第一个参数传递给self 通俗的话讲，就是谁调用这个方法就是谁
## __init__
# 当创建实例对象成功后，有Python解释器来调用该方法，这个方法不用我们手动调用
## id() 方法 即看到的是创建对象在内存中的地址
print(id(zhangsan)) # 例：140142702677008
## __str__() 当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据
print(zhangsan) # welcome people
## __del__方法 创建多个对象的时候触发__del__方法
# 再创建一个zhangsan2
zhangsan2=People()
zhangsan2.age=23 # python解释器开始回收23
面向对象特征：封装
## 封装
## 公有成员变量和私有成员变量
'''
python中用成员变量的名字来区分是共有成员变量或者是私有成员变量。
python中，以两个下划线‘__’开头的变量都是私有成员变量，而其余的变量都属于公有成员变量。
其中，私有的成员变量只能在类的内部访问，而共有的公有的成员变量可以在类的外部进行访问。
'''
class Person(object):
def __init__(self, name):
self.__name = name
def get_name(self):
return self.__name
lisi = Person("lisi1")
print(lisi.get_name())
# print(lisi.__name)#会报错
## 公有方法和私有方法
'''
类的方法也分为公有方法和私有方法。
类的私有方法只能通过对象名（在类内部也就是self）在类的内部进行访问。
而公有方法可以在类的外部通过对象名进行访问。
'''
class Test(object):
#普通方法
def test(self):
print("普通方法test")
#普通方法
def _test1(self):
print("普通方法_test1方法")
#私有方法
def __test2(self):
print("私有方法__test2方法")
t = Test()
t.test()
t._test1()
#t.__test2()#调用的时候会报错
'''
python中对象有两种：经典对象和新型对象。
经典对象就是不继承object父类定义出来的对象。
新型对象就是要继承object类定义出的对象。
新型对象和经典对象最大的区别就是，新型对象中提供了对类方法和静态方法的支持。
类方法就是被classmethod()函数处理过的函数，能够直接通过类名进行调用，也能够被对象直接调用。
静态方法相当于类层面的全局函数，可以被类直接调用，可以被所有实例化对象共享，通过staticmethod()定义静态方法，静态方法没有self参数。
'''
class People2(object):
#类属性
country = "中国"
def __init__(self,name):
self.name = name
#静态方法
@staticmethod
def get_country():
return People2.country
@staticmethod
def print_info(info):
print(info)
#调用静态方法
print(People2.get_country()) # 中国
面向对象特征：继承
# 定义一个父类，如下: 注意点-私有的属性和方法不会被继承
class Cat(object):
def __init__(self, name, color="白色"):
self.name = name
self.color = color
def run(self):
print("%s--在跑"%self.name)
def say(self):
print("%s--在叫"%self.name)
# 定义一个子类，继承Cat类如下:
class ZhongGuoCat(Cat):
def set_name(self, newName):
self.name = newName
def eat(self):
print("%s--在吃"%self.name)
# 重写父类
def run(self):
print("%s--在跑"%self.name)
# super() 调用父类
super().say()
zhongGuoCat= ZhongGuoCat("中国猫")
print('ZhongGuoCat的名字为:%s'%zhongGuoCat.name)
print('ZhongGuoCat的颜色为:%s'%zhongGuoCat.color)
zhongGuoCat.eat()
zhongGuoCat.set_name('波斯')
zhongGuoCat.run()
'''
ZhongGuoCat的名字为:中国猫
ZhongGuoCat的颜色为:白色
中国猫--在吃
波斯--在跑
波斯--在叫
'''
## 多继承
# 定义一个父类
class A:
def printA(self):
print('----A----')
# 定义一个父类
class B:
def printB(self):
print('----B----')
# 定义一个子类，继承自A、B
class C(A,B):
def printC(self):
print('----C----')
obj_C = C()
obj_C.printA() # ----A---
obj_C.printB() # ----B---
print(C.__mro__) # 搜索搜索过程:(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)
面向对象特征：多态
## 所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态。
## 多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）
class F1(object):
def show(self):
print('F1.show')
class S1(F1):
def show(self):
print('S1.show')
class S2(F1):
def show(self):
print('S2.show')
## Func函数需要接收一个F1类型或者F1子类的类型
def Func(obj):
obj.show()
s1_obj = S1()
Func(s1_obj) # 在Func函数中传入S1类的对象 s1_obj，执行 S1 的show方法 S1.show
s2_obj = S2()
Func(s2_obj) # 在Func函数中传入Ss类的对象 ss_obj，执行 Ss 的show方法 S2.show
异常
'''
异常即是一个事件，该事件会在程序执行过程中发生，影响了程序的正常执行。
一般情况下，在Python无法正常处理程序时就会发生一个异常。
异常是Python对象，表示一个错误。
当Python脚本发生异常时我们需要捕获处理它，否则程序会终止执行。
'''
# error =1/0 # 这样明显的会报错误：ZeroDivisionError
try:
error =1/0
except ZeroDivisionError:
print('发生了异常') # 这样不会报错，程序可以正常执行
## 还可以使用else
try:
success =1/1
except ZeroDivisionError:
print('发生了异常')
else:
print("程序没有异常")
## try...finally...
try:
error1 =1/0
except ZeroDivisionError:
print('发生了异常')
finally:
print("不管是否错误或者正确都执行finally")
## 使用raise抛出系统的异常
# if 4>3:
# raise Exception('测试一个raise异常')
## 自定义异常
class MyException(Exception):
def __init__(self,message):
super().__init__()
self.message=message
class TestExcept(object):
def start(self):
try:
content =input("输入内容：")
if len(content) < 3:
raise MyException('测试一个raise异常:长度不够')
except MyException as s:
print(s.message)
testExcept = TestExcept()
testExcept.start()
Python通过两篇文章的介绍，基本上把常用的部分罗列了出来和写了例子，下一步学习更多专注于实践与应用。继续关注一起学习
微信公众号：大数据左右手
人要去的地方，除了远方，还有未来
欢迎关注我，一起学习，一起进步!
2551
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
