函数
几乎所有的编程语言都有函数的概念,函数其实就是一段可重用的代码。
但是不同的语言有自己独特的风格。
我们看一个简单的python函数代码:
def hello():
print("hello")
hello()
#输出 hello
定义方法和其它语言都是类似的,python中我们使用 def
来定义一个函数。
Java中,方法必须在一个类中定义方法,如果向下面这样定义一个函数,就会报错
如果调用执行这个函数,则要在 main()
方法中调用函数。
而Python
中,直接在文件中调用即可
参数
Python
是一门强类型语言
定义python函数的形参时,并不需要指定参数的类型,直接写上参数名即可。
def hello(name):
print("Hello" + name)
hello("Jack")
传递任意数量的实参
def hello(*name):
print(name)
hello("Jack", "Tom", "Anny")
#('Jack', 'Tom', 'Anny')
形参名*name
让Python创建一个名为name的空元组,并将收到的所有值都封装到这个元组中。
导入模块
模块就是扩展名为 .py
的文件
-
导入一个模块
import 模块名
导入模块后我们就可以使用这个模块中的方法了
-
导入特定的函数
from 模块名 import 函数名
-
使用as给函数指定别名
from 模块名 import 函数名 as 函数别名
-
使用as给模块指定别名
from 模块名 as 模块别名
-
导入模块中的所有函数
from 模块名 import *
类
类就相当于一个模板,可以通过这个模板创建相应的对象。
方法
类中的函数称为 方法,但是和方法又和函数有区别
1、函数要手动传self,方法不用传self。
2、如果是一个函数,用类名去调用,如果是一个方法,用对象去调用。
__new__()
__new__()
负责进行对象的创建
只有继承于object的新式类才能有__new__方法,
__new__方法在创建类实例对象时由Python解释器自动调用,一般不用自己定义,
Python默认调用该类的直接父类的__new__方法来构造该类的实例,
如果该类的父类也没有重写__new__,那么将一直按此规矩追溯至object的__new__方法,因为object是所有新式类的基类,若需要自定义__new__方法,一般用法如下:
class Person(object):
def __new__(cls):
return object.__new__(cls)
__new__至少要有一个参数cls,代表要实例化的类,此参数在实例化时由Python解释器自动提供;
__new__必须要有返回值,返回实例化出来的实例,可以return父类new出来的实例,或直接是object的new出来的实例。
object.new(cls)执行完返回的结果为Person类的实例对象,如下:
class Person(object):
def __init__(self):
print("__init__")
self.name="张三"
def __new__(cls):
print('__new__')
ob = object.__new__(cls)#ob为Person实例对象
print(ob)
return ob
p1 = Person()
print(p1.name)
p1 = Person()
做了如下工作:
- 调用Person的
__new__()方法
__new__()方法
通过object.new(cls)
创建了Person实例对象并返回- 调用Person实例对象的
__init__()
方法
参考:https://blog.csdn.net/weixin_41557802/article/details/84190218
__init__()
Python中 __init__()
方法就是对象的 构造方法,在对象初始化时进行一系列的构建操作。
__init__()
方法必须接受至少一个参数 self
。
self
是指向该对象本身的一个引用,通过在类的内部使用self
变量,类中的方法可以访问自己的成员变量。
class Dog():
def __init__(self, name):
self.name = name
def sit(self):
print(self.name.title() + "is now sitting~")
self.name
就是 访问该对象的name属性
;
-
__new__
至少要有一个参数cls,代表要实例化的类,此参数在实例化时由Python解释器自动提供 -
__new__
必须要有返回值,返回实例化出来的实例,这点在自己实现__new__
时要特别注意,可以return父类__new__
出来的实例,或者直接是object的__new__
出来的实例 -
__init__
有一个参数self,就是这个__new__
返回的实例,__init__
在__new__
的基础上可以完成一些其它初始化的动作,__init__
不需要返回值
__str__()
class Cat:
def __init__(self, new_name, new_age):
"""在创建完对象之后 会自动调用, 它完成对象的初始化的功能"""
# self.name = "汤姆"
# self.age = 20
self.name = new_name
self.age = new_age # 它是一个对象中的属性,在对象中存储,即只要这个对象还存在,那么这个变量就可以使用
def __str__(self):
return "名字是:%s , 年龄是:%d" % (self.name, self.age)
tom = Cat("汤姆", 30)
print(tom)
输出:
- 在python中方法名如果是
__xxxx__()
的,那么就有特殊的功能,因此叫做“魔法”方法 - 当使用print输出对象的时候,只要自己定义了
__str__(self)
方法,那么就会打印从在这个方法中return的数据 __str__
方法需要返回一个字符串,当做这个对象的描写
内置函数
Python 内置了很多有用的函数
- 数学运算(7)
- 类型转换(24)
- 序列操作(8)
- 对象操作(7)
- 反射操作(8)
- 变量操作(2)
- 交互操作(2)
- 文件操作(1)
- 编译执行(4)
- 装饰器(3)
数学运算
abs 求绝对值:
abs()
divmod 返回两个数值的商和于数
divmod(5,2)
min 返回可迭代对象中的元素最小值或者所有参数最小值
min(1,2,3) #1
min('1234') #'1'
min('min') #'i'
min(-1,-2) #-2
min(-1,-2,key=abs) # -1, 传入了abs函数,参数都会进行求绝对值都再取较小者
max 返回可迭代对象中的元素最小值或者所有参数最小值
max(1,2,3) #3
max('1234') #'4'
max('max') #'x'
max(-1,-2) #-1
max(-1,-2,key=abs) # -2, 传入了abs函数,参数都会进行求绝对值都再取较大者
pow 返回两个数值的幂运算或其与指定整数的模值
pow(2,3) #8 2^3
pow(2,3,5) #3 2^3%5
pow(2,3)%5 #3 2^3%5
round 对浮点数四舍五入求值
round(1.323423423,1) #1.3
round(1.323423423,5) #1.32342
round(1.65,1) #1.6
round(1.66,1) #1.7
sum 对元素类型是数值的可迭代对象中每个元素求和
sum((1,2,3,4)) #10
sum((1,2,3,4),-11) #-1
类型转换
bool
bool() #False
bool(0) #False
bool(1) #True
bool(2) #True
int
int() #0
int(2.5) #2
float
float() #0.0
float(3) #3.0
float('3')#3.0
complex
complex() #0j
complex('1+2j') #(1+2j)
complex(1,2) #(1+2j)
str
str() #''
str(None) #'None'
str('abc') #'abc'
str(123) #'123'
bytearray 根据传入的参数创建一个新的字节数组:
bytearray('中文','utf-8')
bytearray(b'\xe4\xb8\xad\xe6\x96\x87')
bytes 根据传入的参数创建一个新的字节数组:
bytes('中文','utf-8')
memoryview:根据传入的参数创建一个新的内存查看对象:
v = memoryview(b'abcefg')
v[1]
v[-1]
ord:返回Unicode字符对应的整数:
ord('a')
chr:返回整数所对应的Unicode字符:
chr(97) #参数类型为整数
bin:将整数转换成2进制字符串
oct:将整数转化成8进制数字符串
hex:将整数转换成16进制字符串
bin(3)
oct(3)
hex(3)
tuple:根据传入的参数创建一个新的元组:
tuple() #不传入参数,创建空元组
tuple('121') #传入可迭代对象。使用其元素创建新的元组
list:根据传入的参数创建一个新的列表:
list() # 不传入参数,创建空列表
list('abcd') # 传入可迭代对象,使用其元素创建新的列表
dict:根据传入的参数创建一个新的字典:
dict() # 不传入任何参数时,返回空字典。
dict(a = 1,b = 2) # 可以传入键值对创建字典。
dict(zip(['a','b'],[1,2])) # 可以传入映射函数创建字典。
dict((('a',1),('b',2))) # 可以传入可迭代对象创建字典。
set:根据传入的参数创建一个新的集合:
set() # 不传入参数,创建空集合
a = set(range(10)) # 传入可迭代对象,创建集合
a
frozenset:根据传入的参数创建一个新的不可变集合:
a = frozenset(range(10))
a
enumerate:根据可迭代对象创建枚举对象:
seasons = ['Spring', 'Summer', 'Fall', 'Winter']
list(enumerate(seasons))
list(enumerate(seasons, start=1)) #指定起始值
range:根据传入的参数创建一个新的range对象:
a = range(10)
b = range(1,10)
c = range(1,10,3)
a,b,c # 分别输出a,b,c
list(a),list(b),list(c) # 分别输出a,b,c的元素
iter:根据传入的参数创建一个新的可迭代对象:
a = iter('abcd') #字符串序列
a
next(a)
a = iter('abcd')
next(a) #'a'
next(a) #'b'
next(a) #'c'
next(a) #'d'
slice:根据传入的参数创建一个新的切片对象:
c1 = slice(5) # 定义c1
c1
c2 = slice(2,5) # 定义c2
c2
c3 = slice(1,10,3) # 定义c3
c3
super:根据传入的参数创建一个新的子类和父类关系的代理对象:
#定义父类A
class A(object):
def __init__(self):
print('A.__init__')
#定义子类B,继承A
class B(A):
def __init__(self):
print('B.__init__')
super().__init__()
#super调用父类方法
b = B()
B.__init__
A.__init__
object:创建一个新的object对象:
a = object()
a.name = 'kim' # 不能设置属性
## 序列操作
all 判断可迭代对象是否都为True
all(()) #True
all({}) #True
all([]) #True
all([0]) #False
all([1,2]) #True
all([0,1,2]) #False
any 判断可迭代对象的元素是否有为True的元素
any(()) #False
any([]) #False
any({}) #False
any([0]) #False
any([1,2]) #True
any([0,1,2]) #True
filter 使用指定方法过滤可迭代对象的元素
a = list(range(1,10)) #定义序列
a
def if_odd(x) #定义奇数判断函数
return x%2 == 1
list(filter(if_odd,a))#筛选序列中的奇数
#[1, 3, 5, 7, 9]
map 使用指定方法去作用传入的每个可迭代对象的元素,生成新的可迭代对象
a = map(ord,'abcd')
a
list(a)
#[97, 98, 99, 100]
next 返回可迭代对象中的下一个元素值
a = iter('abcd')
next(a) #'a'
next(a) #'b'
next(a) #'c'
next(a) #'d'
reversed 反转序列生成新的可迭代对象
a = reversed(range(10)) #传入range对象
a #类型变成迭代器
list(a)
#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
sorted 对可迭代对象进行排序,返回一个新的列表
sorted(a,key = str.lower) # 转换成小写后再排序,'a’和’A’值一样,'b’和’B’值一样
a = ['a','b','c','B','A']
a
sorted(a)
#['A', 'B', 'a', 'b', 'c', 'd']
zip 聚合传入的每个迭代器中相同位置的元素,返回一个新的元组类型迭代器
x = [1,2,3]
y = [9,8,7,6]
list(zip(x,y))
#[(1,9), (2,8), (3,7)]
对象操作
help:返回对象的帮助信息:
help(str)
](https://www.ipieuvre.com/doc/exper/34340a37-91ad-11e9-beeb-00215ec892f4/img/d2fba91d-dabf-48c2-bb12-d3c320fbd762.png)
注:如果要从help中退出,请按q键
dir:返回对象或者当前作用域内的属性列表:
import math
math
dir(math)
id:返回对象的唯一标识符:
a = 'some text'
id(a)
hash:获取对象的哈希值:
hash('good good study')
type:返回对象的类型,或者根据传入的参数创建一个新的类型:
type(1) # 返回对象的类型
len:返回对象的长度:
len('abcd') # 字符串
len([1,2,3,4]) # 列表
ascii:返回对象的可打印表字符串表现方式:
ascii(1)
ascii('&')
ascii(9000000)
ascii('中文') #非ascii字符
format:格式化显示值:
"{} {}".format("hello", "world") # 不设置指定位置,按默认顺序
"{0} {1}".format("hello", "world") # 设置指定位置
"{1} {0} {1}".format("hello", "world") # 设置指定位置
### 添加参数
print("urlname:{name}, addr {url}".format(name="zhangyu",url="www.ipieuvre.com"))
### 数字格式化
print("{:.2f}".format(3.1415926));
vars:返回当前作用域内的局部变量和其值组成的字典,或者返回对象的属性列表:
class zhangyu:
a = 1
print(vars(zhangyu))