python中def fun(a、b=200)_Python基础知识学习

注释方法

# 单行注释

''' 多行注释 '''

数据类型

查看数据类型函数

type(变量) 返回该变量的数据类型

数据类型转换函数

int(num) 将num转换为整数类型

float(num) 将num转换为浮点数类型

bool(num) 将num转换为布尔类型

str(num) 将num转换为字符串类型

注：int bool float 任何两种类型都可相互转换

任何类型都可以转换为字符串

注：str -> int 要求全部为数字

str -> float 要求全部为数字，且可存在一个小数点

注：当布尔值False转换为str后， 在转换为bool会变成True

输入和输出

输入

语法 inp = input('提示文本')

注：输入结果为str数据类型，如须做其他操作可进行数据转换

输出默认输出

print('hello, world')占位符输出

# %s 的s表示变量的数据类型

print('名字：%s，年龄：%s，性别：%s' % (name, age, sex))推荐使用

print(f'名字：{name}，年龄：{age}，性别：{sex}')

算数运算符

+ - * / ** // %

前四个同其他编程语言用法相同

** 表示平方计算 5 ** 2 === 5的2次方

// 表示做除运算后取整

% 取余运算

简写形式

+= -= *= /= **= //+ %=

注：

+ 也可用于字符串拼接

* 当任意一边为字符串时，则表示重复字符串

常用运算函数

round(num, count) 表示对num四舍五入，并保留小数点后count位

比较运算符

> < >= <= = !=

常用函数ord(chr) 返回该chr的ASCII码(只能为单个字符)

chr(num) 返回该ASCII对应的字符

分支

单分支

# 注意缩进

if bool表达式:

print('执行')

双分支

# 注意缩进

if bool表达式:

print('执行语句1')

else:

print('执行语句2')

分支嵌套

# 注意缩进

if bool表达式:

if bool表达式2:

print('执行嵌套语句')

else:

print('执行语句1')

else:

print('执行语句2')

多分支

# 注意缩进

if bool表达式1:

print('执行语句1')

elif bool表达式2:

print('执行语句2')

elif bool表达式...:

print('执行语句...')

else:

print('如上都不满足，则执行这条语句')

循环

循环控制只能在循环语句中使用，只对距离最近的循环起作用

break # 跳出本循环

continue # 结束本次循环，执行下一次循环

while循环

# 注意判断条件

while bool表达式:

print('执行语句')

for循环

# range(start, end, rule) 从start开始，到end-1，间隔为rule,rule的正负表示正序或倒序

# range(1, 11) 输出1~10，不包括最大值11

# range(1, 11, 2) 输出1~10，不包括最大值11, 第三个参数表示为每次间隔2

# range(11, 1, -2) 输出11~2，不包括最小值值1, 第三个参数为负数，则表示为倒序且每次间隔2

# range(5) 简写形式，0~5的范围

for i in range(1,11):

print(i)

循环else结构只有循环完整执行完毕后，才会执行else语句

当循环过程中执行break语句后，else将不执行

# while

while bool表达式:

print('执行语句')

else:

print('while else语句')

# for

for i in range(10):

print('执行语句')

else:

print('for else语句')

列表对象是存储单个数据的容器，而列表(数组)就是存储多个数据的容器，任何数据类型都可以存放

# 字面量创建新列表

lst = [1,'2','三']

# 使用list函数创建新列表

lst = list([1,'2','三'])

列表的取值通过索引下标取值

使用for循环

获取元素的下标list.index(‘元素’) 找不到元素则抛出异常， 可预先使用in方法判断是否存在

获取列表中多个元素(切片)

list[start:end:step]

从start索引位置开始，截取到end-1位置结束，步长为step

其中step可为负值，表示从start位置往左边截取开始

start默认值为0

end默认值为列表长度

step默认值为1

省略参数但 : 必须存在 list[::]

列表的增删改操作

增加append(item)

在原有的列表末尾添加一个元素

lst = [10, 20, 30]

lst.append(100)

print(lst) # [10, 20, 30, 100]extend( [] )

在原有的列表末尾至少添加一个元素，添加元素必须是列表(添加多个)

lst = [10, 20, 30]

lst.extend([99, 100])

print(lst) # [10, 20, 30, 99, 100]insert(index, item)

在原有的列表指定位置添加一个元素

lst = [10, 20, 30]

lst.insert(1, 99)

print(lst) # [10, 99, 20, 30]切片添加多个元素(指定位置添加多个元素)

使用切片把选择到的元素替换掉

lst = [10, 20, 30]

lst[1:] = [99]

print(lst) # [10, 99]

删除remove(item)

在原有的列表删除一个元素，如果有重复元素只删除一个，如果元素不存在则抛出异常

lst = [10, 20, 30]

lst.remove(20)

print(lst) # [10, 30]pop(index)

删除指定索引位置的元素，如果指定索引不存在则抛出异常

不传index，则删除末尾元素

lst = [10, 20, 30]

lst.pop(1)

print(lst) # [10, 30]clear()

清空列表

lst = [10, 20, 30]

lst.clear()

print(lst) # []切片删除元素

使用切片把选择到的元素替换为空

lst = [10, 20, 30]

lst[1:] = []

print(lst) # [10]删除列表，即释放内存(谨慎使用)

lst = [10, 20, 30]

del lst

print(lst) # 会抛出异常， lst is not defined

修改直接重新赋值

lst = [10, 20, 30]

lst[1] = 40

print(lst) # [10, 40, 30]切片修改(批量修改)

lst = [10, 20, 30]

lst[1:3] = [40, 50, 60]

print(lst) # [10, 40, 50, 60]

列表的排序sort()

在原列表的基础上排序

传入reverse=True降序排序

传入reverse=False升序排序

不传默认升序

# sotr()

lst = [9, 3, 2, 8]

lst.sort()

print(lst) # [2, 3, 8, 9]

# sotr(reverse=True)

lst = [9, 3, 2, 8]

lst.sort(reverse=True)

print(lst) # [9, 8, 3, 2]

# sotr(reverse=False)

lst = [9, 3, 2, 8]

lst.sort(reverse=False)

print(lst) # [2, 3, 8, 9]sorted(lst[,rule ])

使用内置函数sorted()进行排序，将产生一个新列表对象

传入第二参数reverse=True降序排序

传入第二参数reverse=False升序排序

不传第二参数默认升序

# sorted(lst)

lst = [9, 3, 2, 8]

new_list = sorted(lst)

print(new_list) # [2, 3, 8, 9]

# sorted(lst, reverse=True)

lst = [9, 3, 2, 8]

new_lsit = sorted(lst, reverse=True)

print(new_list) # [9, 8, 3, 2]

# sorted(lst, reverse=False)

lst = [9, 3, 2, 8]

new_lsit = sorted(lst, reverse=False)

print(new_list) # [2, 3, 8, 9]

列表生成式[i for i in renge(1, 11)]

列表生成的表达式

lst = [i*i for i in renge(1, 6)]

print(lst) # [1, 4, 9, 16, 25]

列表常用函数len(list)：列表元素个数

max(list)：返回列表元素最大值

min(list)：返回列表元素最小值

字典(对象)

python的内置数据结构之一，以键值对的方式存储数据。在其他语言中也叫对象。

字典的创建方式info = {'name':'zzl', 'age':18}

info = dict(name='zzl', age=18)

字典的常用操作获取字典中的元素

info = {'name':'zzl', 'age':18}

# []方式

print(info['name']) # zzl

print(info['sex']) # error: keyError

# get()方式

print(info.get('name')) # zzl

print(info.get('sex')) # None

print(info.get('sex', '男')) # 如果sex字段为None的话，则打印 '男' 默认值key的判断

in, not in

info = {'name':'zzl', 'age':18}

# in

print('name' in info) # True

# not in

print('sex' not in info) # Truekey的删除

info = {'name':'zzl', 'age':18}

del info['name'] # 删除name字段

print(info) # {'age':18}

info.clear() # 清空该字典

print(info) # {}新增key

info = {'name':'zzl', 'age':18}

info['sex'] = '男'

print(info) # {'name':'zzl', 'age':18, 'sex':'男'}修改key

info = {'name':'zzl', 'age':18}

info['age'] = 20

print(info) # {'name':'zzl', 'age':20}

获取字典的试图方法keys()

返回字典的所有key组成的列表

info = {'name':'zzl', 'age':18}

keys = info.keys()

print(keys) # ['age', 'name']values()

返回字典的所有value组成的列表

info = {'name':'zzl', 'age':18}

values = info.value()

print(values) # [18, 'zzl']items()

返回字典的所有key:value组成的列表

info = {'name':'zzl', 'age':18}

itmes = info.items()

print(items) # [('age', 18), ('name', 'zzl')]

字典的遍历

info = {'name':'zzl', 'age':18}

for item in info:

print(item，info[item])

# age 'zzl'

# name 18

字典的生成式

items = ['Fruits', 'Books', 'Others']

prices = [98, 97, 95]

d = { item:price for item, price in zip(items, prices) }

print(d) # {'Others': 95, 'Books': 97, 'Fruits': 98}

字典的特点字典中的所有元素都是一个key-value对，key不允许重复，value可以重复

字典中的元素是无序的

字典中的key必须是不可变对象，(即key不能为变量)

字典也可以根据需要动态的伸缩

字典会浪费较大的内存，是一种使用空间换时间的数据结构

元组列表的另一种形式，是不可变序列

元组的创建方式

# 直接用小括号书写

t = ('python', 'world', '20')

# 使用内置函数tuple()

t1 = tuple( ('python', 'world', '20') )

t3 = ('python',) # 如果元组只有一个元素，则在元素后面加上 ，

# 获取元组的元素

t[0] # python

元组的遍历

t = ('python', 'world', '20')

for item in t:

print(item)

# python

# world

# 20

注：如果元组中对象本身是不可变对象，则不能再引用其他对象

如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变

集合python语言提供的内置数据结构

与列表、字典都属于可变类型的序列

集合是没有value的字典

集合的存储是无序的

集合的创建

# 集合的value不能重复

s = {2, 3, 4, 5, 2, 4}

print(s) # {2,3,4,5}

# set()函数

s1 = set(range(6))

print(s1) # set([0, 1, 2, 3, 4, 5])

s2 = set([1,2,3,5,6,4,3])

print(s2) # set([1, 2, 3, 4, 5, 6])

s3 = set((1,23,5,32,1))

print(s3) # set([32, 1, 5, 23])

s4 = set('python')

print(s4) # set(['h', 'o', 'n', 'p', 't', 'y'])

s5 = set({12,4,23,4,12})

print(s5) # set([12, 4, 23])

# 定义集合

s6 = set()

集合的常用操作

s = {10, 20, 30, 40, 50}

# 判断是否存在

print(10 in s) # True

print(70 in s) # False

# 新增

s.add(80)

print(s) # {10, 20, 30, 40, 50, 80}

# 新增多个

s.update({200, 400})

print(s) # {10, 20,, 200, 30, 40, 50, 400, 80}

# 删除

s.remove(10)

print(s) # {20,, 200, 30, 40, 50, 400, 80}

s.remove(900) # error: keyError

s.discard(900) # 如果有则删除900， 没有也不会报错

s.pop() # 随机删除一个， 不能传参

s.clear() # 清空集合

集合间的关系

两个集合是否相等(判断集合中的元素是否完全相等)

s1 = {10, 20, 30, 40}

s2 = {20, 40, 10, 20}

print(s1 == s2) # True

print(s1 != s2) # False

一个集合是否是另一个集合的子集假如集合s1的元素里包括集合s2的全部元素，则s2是s1的子集

s1 = {10, 20, 30, 40}

s2 = {20, 40}

print(s2.issubset(s1)) # True

一个集合是否是另一个集合的超集与上相反，假如集合s1的元素里包括集合s2的全部元素，则s1是s2的超集

s1 = {10, 20, 30, 40}

s2 = {20, 40}

print(s1.issuperset(s2)) # True

一个集合和另一个集合是否无交集如果一个集合里某个元素，在另一个集合里也有存储，则两个集合有交集

s1 = {10, 20, 30, 40}

s2 = {80, 60}

print(s1.isdisjoint(s2)) # False 无交集

字符串格式化操作

# %s 的s表示数据类型 s:字符串 i:整数

print('我叫%s，我今年%i岁' % ('zzl', 18)) # 我叫zzl，我今年18岁'

# {}里的数字表示后面变量的索引，可重复使用

print('我叫{0}，我今年{1}岁，我真的叫{0}'.format('zzl', 18)) # 我叫zzl，我今年18岁，我真的叫zzl'

# 前面加f 可在{}中直接填写变量

print(f'我叫{'zzl'}，我今年{18}岁') # 我叫zzl，我今年18岁'

字符串编码和解码操作

# 编码

s = '好好学习，天天向上'

# 使用GBK格式进行编码, 此格式中，一个中文占两个字节

print(s.encode(encoding='GBK')) #b'\xba\xc3\xba\xc3\xd1\xa7\xcf\xb0\xa3\xac\xcc\xec\xcc\xec\xcf\xf2\xc9\xcf'

# 使用UTF-8格式进行编码 此格式中，一个中文占三个字节

print(s.encode(encoding='UTF-8')) #b'\xe5\xa5\xbd\xe5\xa5\xbd\xe5\xad\xa6\xe4\xb9\xa0\xef\xbc\x8c\xe5\xa4\xa9\xe5\xa4\xa9\xe5\x90\x91\xe4\xb8\x8a'

# 解码 (使用什么格式编码，就必须使用什么格式解码，否则会报错)

# 使用GBK格式进行编码

print(s.encode(encoding='GBK').decode(encoding='GBK')) # 好好学习，天天向上

# 使用UTF-8格式进行编码

print(s.encode(encoding='UTF-8').decode(encoding='UTF-8')) # 好好学习，天天向上

函数

函数的定义和使用

# 定义

def 函数名(a, b): # 参数a和b

函数体

return # 返回值

# 使用

函数名()

# 代码演示

def cals(a, b):

c = a + b

return c

res = cals(20, 30) # 50

函数的参数传递位置传参，cals(20, 30) ，此时a的值是20， b的值是30

关键字传参， cals(b=70, a=30) 此时a的值是30， b的值是70

函数的返回值如果函数没有返回值(函数执行完毕之后，不需要给调用处提供数据),return可以省略不写

函数的返回值，如果是1个，直接返回原值

函数的返回值，如果是多个，返回的结果为元组

def fun(lst):

odd = [] # 存放奇数

even = [] # 存放偶数

for i in lst:

if (i%2) :

odd.append(i)

else:

even.append(i)

return odd,even

lst = [10, 23, 65, 78, 32, 77]

print(fun(lst)) # ([23, 65, 77], [10, 78, 32])

函数的默认值

在定义函数的时候，可以给形参赋上默认值，当没传参数的时候，函数会取默认值，如果传参和默认值同时存在，传的参数会替换掉默认值

def cals(a, b = 10):

c = a + b

return c

res = cals(20) # 30

res = cals(20, 30) # 50

函数的参数定义个数可变的位置参数

定义函数时，可能无法确定传递的实参个数，这个时候就要使用可变的位置形参。使用*定义，结果为一个元组

def fun(*args);

print(args)

fun(1) # (1,)

fun(1,2,3) # (1, 2, 3)个数可变的关键字参数(指定参数名传递参数)

定义函数时，可能无法确定传递的关键字实参个数，这个时候就要使用可变的关键字形参。使用*定义，结果为一个字典

def fun(**args);

print(args)

fun(a=10) # {'a':10}

fun(a=10, b=20, c=30) # {'a':10, 'b':20, 'c':30}

以上参数在函数定义时，一种方式只能定义一次。

当两种参数定义方式同时存在时，位置形参必须在关键字形参前面

python异常处理机制

异常捕获

try:

可能出现异常的语句放在这里

except 你要捕获的异常类型:

捕获到异常后你想做什么

except 你要捕获的异常类型:

捕获到异常后你想做什么

...

except BaseException as e: # 这种情况是以上异常类型都没捕获到，则执行这块代码

print('出错了', e)

print('程序照常执行')

异常捕获else

try:

可能出现异常的语句放在这里

except 你要捕获的异常类型:

捕获到异常后你想做什么

except 你要捕获的异常类型:

捕获到异常后你想做什么

...

except BaseException as e: # 这种情况是以上异常类型都没捕获到，则执行这块代码

print('出错了', e)

else:

print('如果没有异常则执行else部分')

try…except…else…finally结构

try:

a = int(input('请输入第一个整数'))

b = int(input('请输入另一个整数'))

res = a/b

except BaseException as e:

print('出错了', e)

else:

print('结果为:'res)

finlly:

print('无论是否产生异常，总会被执行的代码')

类与对象

类的创建类属性: 类中方法外的变量称为类属性，被该类的所有实例对象共享

类方法: 使用@classmethod修饰的方法，可使用类名直接访问

静态方法: 使用@staticmethod修饰的方法，可使用类名直接访问

# Stubent为类的名称，由一个或多个单词组成。(建议类名书写方式为每个单词首字母大写)

class Student:

native_pace = '河南' # 直接写在类里的变量，称为属性

# 初始化函数( 构造函数 )

def __init__(self, name ,age):

# 创建实例的时候 对name和age属性进行赋值

self.name = name

self.age = age

# 定义在类里面的方法为实例方法

def eat(self):

print('吃饭')

# 静态方法 (静态方法里不允许写self)

@staticmethod

def method():

print('使用staticmethod进行修饰，所以我是静态方法')

# 类方法

@classmethod

def cm(cls):

print('使用calssmethod进行修饰，所以我是类方法')

类实例对象

# 类实例创建语法 stu = Student()

# 假设已存在上面的 Student 类

# stu1就是Student类的实例对象，该实例对象中可以访问到类中的属性和方法

stu1 = Student('zzl', 18) # 创建实例

print(stu1.name) # zzl

print(stu1.age) # 18

stu1.eat() # 吃饭

动态绑定属性和方法

# 假设已存在Student类

stu = Student('zzl', 18)

# 绑定 gender 属性

stu.gender = '男'

print(stu.gender) # 男

# 绑定 show 方法

def show():

print('show方法执行')

stu.show = show

stu.show() # show方法执行

面向对象的三大特征封装 (提高程序的安全性)

将数据(属性)和行为(方法)封装到类对象中，在方法内部对属性进行操作，在类对象的外部调用方法。这样无需关心方法内部的具体实现细节，从而隔离了复杂度。在python中没有专门的修饰符用户属性的私有化，如果该属性不想被类对象访问，可以在属性名前面加两个 ‘_’

继承

多态

代码演示

# 继承

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_no):

super().__init__(name, age)

self.stu_no = stu_no

class Teacher(Person):

def __init__(self, name, age, teachofyear):

super().__init__(name, age)

self.teachofyear = teachofyear

stu = Student('张三', 20, 10001)

teacher = Teacher('李四', 35, 10)

stu.info() # 张三 20

teacher.info() # 李四 35

# python 支持多继承

class A(class1, class2):

pass

# 方法重写

# 方法重写就是在子类里定义与父类重名的方法，这样就会优先调用子类的定义的方法

模块和包定义：每一个.py文件就是一个模块

使用模块化的好处方便其他程序和脚本的导入使用

避免函数名和变量名冲突

提高代码的可维护性

提高代码的可重用性

导入模块

# 导入模块

import 模块名称 [as 别名]

# 导入模块中的指定函数(or 变量 or 类)

from 模块名称 import 函数/变量/类

包包是一个分层次的目录结构，它将一组功能相近的模块组织在一个目录下

作用代码规范

避免模块名称冲突

包与目录的区别包含__init__.py文件的目录称为包

目录里通常不存在__init__.py文件

包的导入

import 包名.模块名

文件的读写

内置函数open()创建文件对象

# file = open( filename, [mode, encoding] )

# 假设有一个名为a的文本文件，里面有hello world

file = open('a.txt', 'r')

print(file.readlines()) # ['hello world']

file.close()

with语句(上下文管理器)with语句可以自动管理上下文资源，不论什么原因跳出with语句都能确保文件正确的关闭，以此来达到释放资源的目的

# with使用

with open(filename, mode) as file:

pass

目录操作 (os 和 os.path)os模块是python内置的与操作系统功能和文件系统相关的模块，该模块中的语句的执行结果通常与操作系统有关，在不同的操作系统上运行，得到的结果可能不一样

os模块与os.path模块用于对目录或文件进行操作

import os

# 打开计算器

os.system('calc.exe')

# 打开记事本

os.system('notepad.exe')

# 打开可执行文件

os.startfile('路径')