入门Python基础小进阶

微信公众号：王了个博

专注于大数据技术，人工智能和编程语言

个人既可码代码也可以码文字。欢迎转发与关注

Python入门小进阶

接着上一篇目继续学习python

上一篇链接：半天轻轻松松入门python

本篇主要学习内容

函数

文件操作

文件夹操作

面向对象

异常

函数

## 定义函数 标识符由字母、下划线和数字组成，且数字不能开头

'''

def 函数名():

代码

'''

## 调用函数

'''

函数名()

'''

## 例子（九九乘法表）

##定义一个名字叫print_99的函数

def print_99():

i = 1

while i 

j = 1

while j 

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()

参数说明列表简单的文件复制

## 简单的文件复制

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 

#     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 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) 

raise MyException('测试一个raise异常:长度不够')

except MyException as s:

print(s.message)

testExcept = TestExcept()

testExcept.start()

Python通过两篇文章的介绍，基本上把常用的部分罗列了出来和写了例子，下一步学习更多专注于实践与应用。继续关注一起学习

微信公众号：王了个博

人要去的地方，除了远方，还有未来

欢迎关注我，一起学习，一起进步!