Python

Python基础篇之函数

2019-12-23  本文已影响0人  山水墨阳

函数是具有特定功能可重复利用的代码块，有名字、参数（可选）、返回值（可选），又叫做方法。本篇介绍函数的定义、函数的参数、函数的返回值、函数的调用及Python内置函数。

云时代怎能没有云服务器，让应用飞起来吧

函数的定义

1、函数通过def关键字定义，def是define的缩写;
2、函数名称是一个有效的标识符;
3、函数名后面是一个括号，内部可传入0到多个参数，逗号隔开；
4、函数内容以冒号开始并缩进；
5、return 关键字结束函数并返回。没有return 默认返回None;
形如：

#a,b两个参数必须是相同类型且可加的
def getAdd(a,b):
    "返回两个数的最大值"
    return a+b

这里的getAdd为函数名，括号内a,b为两个参数。

函数的参数

函数括号内的参数可有可无，参数不用申明具体数据类型（Python中的变量都不用申明特定的类型，Python自动识别），多个参数用逗号隔开。函数名称括号内的参数为形参，传入的实际值为实参。

函数的返回值

函数的返回值为前面提到的七大基本类型：数字（Number 包括：int-整型，long-长整型，float-浮点型，complex-复数）、字符串（str）、列表（list）、集合（set）、元组（tuple）、字典（dict）、None。

函数的调用

函数的调用在可用的情况下直接使用其函数名，传入对应的参数，有返回值的用变量接受返回值即可。注意：这里的可用的情况是条件的，同一个脚本文件中的函数在本脚本中可直接使用，其他的脚本中申明的函数需要引入模块后才能直接使用。

#调用函数
c = getAdd(1,2)
print(c)#输出3
c = getAdd('darker','wang')
print(c)#darkerwang

Python内置函数

Python中封装了常用的基本内置函数，整理如下：

0、输入输出函数

x = inpupt("请录入:")#等待录入数据，赋值给x
print(x)#打印录入的数据

1、数据类型函数

原始七大数据类型对应的构造函数

x = int(1)# 构造一个整型对象
print(type(x)) #输出为 <class 'int'>
print("x="+str(x))#输出为 x=1

'''
long() python2函数，python3已弃用，python3只有int
如果int内参数溢出python3自动构造成一个长整型
'''

x = float()#构造一个浮点型对象
print(type(x)) #输出为 <class 'int'>
print("x="+str(x))#输出为 x=1

x = complex()#构造一个复数对象
print(type(x)) #输出为 <class 'float'>
print("x="+str(x))#输出为 x=0.0

x = bool()#构造一个布尔对象
print(type(x)) #输出为 <class 'complex'>
print("x="+str(x))#输出为 x=0j

x = list()#构造一个列表对象
print(type(x)) #输出为 <class 'bool'>
print("x="+str(x))#输出为 x=False

x = set()#构造一个集合对象
print(type(x)) #输出为<class 'set'>
print("x="+str(x))#输出为 x=set()

x = dict()#构造一个字典对象
print(type(x)) #输出为 <class 'dict'>
print("x="+str(x))#输出为 x={}

x = str()#构造一个字符串对象
print(type(x)) #输出为 <class 'str'>
print("x="+str(x))#输出为 x=

x = tuple()#构造一个元组对象
print(type(x)) #输出为 <class 'tuple'>
print("x="+str(x))#输出为 x=()

2、非数据类型函数

x = abs(-1)
print(x)#输出1

x = list()
print(x.__len__())#输出长度0
print(all(x))#无元素，返回True
x.append(0)#添加一个0元素，
print(all(x))#有一个0元素，返回False
x.append(False)#添加一个False元素
print(all(x))#有False元素，返回False
x[0]=1#第一个元素重新赋值为1，非0
print(x)#打印目前x [1,False]
print(all(x))#还有一个False元素，返回False
x[1]=True#将第二个False元素赋值为True
print(all(x))#没有0或者False元素，返回True
print(x)#打印最终x [1,True]

x = list()
print(any(x))#x元素为空，没有任何一个为真(非0或False)，返回False
x.append(0)#添加一个0（False）
print(any(x))#没有一个为真，返回False
x.append(True)#添加一个True
print(x)#打印此时x [0,True]
print(any(x))#x 有一个为真，返回真（True）

x[0] = 1#第一个元素为非0（真）
x[1] = False#第二个元素为否
print(x)#打印此时x[1,False]
print(any(x))#x有一个为真，返回真（True）

x[0] = 1#第一个元素为真（非0）
x[1] = 2#第二个元素为真（非0）
print(x)#打印此时的x[1,2]
print(any(x))#两个元素都为真（非0），返回真（True）

x[0] = 0#第一个元素为0
x[1] = -1#第二个元素为非0
print(x)#打印此时x[0,-1]
print(any(x))#有一个元素为真（非0），则返回True

isinstance() 与 type() 区别：
type() 不会认为子类是一种父类类型，不考虑继承关系。
isinstance() 会认为子类是一种父类类型，考虑继承关系。
如果要判断两个类型是否相同推荐使用 isinstance()。

from pip._vendor.pyparsing import basestring
x = "2232"
print(isinstance(x,basestring))
print(isinstance(x,str))

print(bin(0))#输出 0b0
print(bin(1))#输出 0b1
print(bin(-122))#输出 -0b1111010

bool()
将参数转为布尔值，参数非0即True

print(bool(0))#输出False
print(bool(-1))#输出True
print(bool(1))#输出True
print(bool(1.2))#输出True
print(bool('abc'))#输出True

形如：class bytearray([source[, encoding[, errors]]])
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。

x = bytearray(4)
print(x.__len__())#单个数字时生成一个指定长度为4的元素都为0的新数组
print(x)#输出 bytearray(b'\x00\x00\x00\x00')
x = bytearray([1,2,4])#数组时长度为新数组长度3
print(x.__len__())#长度为原数组长度
print(x)#输出 bytearray(b'\x01\x02\x04')
x = bytearray('abc','utf-8') #输出 bytearray(b'abc')
print(x.__len__())#数组新数组长度3
print(x)#输出 bytearray(b'abc')

import operator
print(operator.eq(1,3))#equal 判断两个参数是否相等
print(operator.ne(1, 3))#not equal 判断两个参数是否不相等
print(operator.gt(1, 3))#great than 判断大于
print(operator.ge(1, 3))#great equal 大于等于
print(operator.le(1, 3))#little equal 小于等于
print(operator.lt(1,3))#little than 小于

参数
source 字符串或者AST（Abstract Syntax Trees）对象。。
filename 代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。
mode 指定编译代码的种类。可以指定为 exec, eval, single。
flags 变量作用域，局部命名空间，如果被提供，可以是任何映射对象。
flags和dont_inherit是用来控制编译源码时的标志

str = "print('hello world')" 
c = compile(str,'','exec')   # 编译为字节代码对象 
print(c)
exec(c)#执行字节代码

'''
打印内容
<code object <module> at 0x0000000002162810, file "", line 1>
hello world
'''
exec("print('hello world')")#直接exec(字符串的代码)也能正常执行

#自定义一个函数
def testFun():
    print('test')

print(callable(0))#不是对象，函数，返回False
print(callable('abc'))#不是对象，函数，返回False
print(callable(str))#可用函数，返回True
print(callable(exec))#可用函数，返回True
print(callable(testFun))#可用函数，返回True

s = str("abc")#申明一个对象，
print(callable(s))#可用对象，返回True

#自定义一个没有实现__call__()方法的类    
class A(object):
    def aFun(self):
        print("A.aFun")
print(callable(A))#是一个类，返回True
a = A()#申明一个类实例
print(callable(a))#类对象没有实现__call__返回False

#自定义一个实现纳__call__()方法的类    
class A(object):
    def __call__(self):
        print("A.__call_")
print(callable(A))#是一个类，返回True
a = A()#申明一个类实例
print(callable(a))#类对象实现__call__返回True

print(chr(48))#输出48对应的字符 0
print(chr(49))#输出49对应的字符1
print(chr(97))#输出97对应的字符a
print(chr(98))#输出98对应的字符b

print(ord("a"))#输出97
print(ord("1"))#输出49

#自定义一个类
class A(object):
    
    #自定义方法
    def add(self,a,b):
        return a+b
    
    #自定义方法，声明为类方法
    @classmethod
    def getClassName(self):
        return 'A'
    
a = A()#实例化类
print(a.add(1, 2))#实例化调用，输出3
print(a.getClassName())#实例化调用，输出A
print(A.getClassName())#类直接调用，输出A
print(A.add(1, 2))#类直接调用，该方法未声明为类方法执行出错

class A(object):
    @staticmethod
    def method1():
        print('method1')
    
    @classmethod
    def method2(self):
        print("method2")

A.method1()
A.method2()

#创建一个测试类
class ClassA(object):
    a = 'A'#属性a
    b = 'B'#属性b
#实例化对象
ca = ClassA()
print(ca.a)#打印ca对象的属性a，值为A
delattr(ClassA,'a')#删除类的属性a
print(ca.a)#属性已被删除，报错AttributeError: 'ClassA' object has no attribute 'a'

class ClassA(object):
    a = 'A'
    b = 'B'
    c = "123"

ca = ClassA()
print(dir())#当前变量
print(dir(ca))#制定ca对象的变量

x = divmod(7, 2)
print(x)# 输出(3,1)

-enumerate()
将一个可遍历的数据对象（列表，元组，字符串等）组合成一个索引-值序列
注意：一般用于for循环 【常用】
语法：enumerate(sequence, [start=0])
参数：sequence 可遍历对象，可选参数start 下标起始位置，默认0

lists = ['Spring', 'Summer', 'Fall', 'Winter']
for i,v in enumerate(lists):
    print('index='+str(i)+" value="+v)#这里k是下标

idict = {'a':"darker","b":"wang","c":"godbirds"}

#1、直接编列字典
for i,v in enumerate(idict):
    print('index='+str(i)+" value="+str(v))#这里k是下标 ，v是key的值
    
#2、遍历其建
for i,v in enumerate(idict.keys()):
    print('index='+str(i)+" value="+str(v))#与1、同
    
#2、遍历其元素
for i,v in enumerate(idict.items()):
    print('index='+str(i)+" value="+str(v))#这里k是下标,v是内部元素（元组展示）

#3、一般遍历字典我们用如下方法
for i,v in idict.items():
    print('index='+str(i)+" value="+str(v))#这里k是元素的键，v是元素的值

print(eval('1+2'))    #输出3
exec('print(eval("1+2"))')#执行一个语句输出3

execfile('hello.py')#hello.py是编写好的一个文件

#自定义一个函数：判断是否是素数
def is_prime(n):
    if n == 1:
        return False
    for i in range(2,n//2+1):
        if n % i == 0:
            return False
    return True
 
tmplist = filter(is_prime, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,11,12,13,14,15,16,17])
newlist = list(tmplist)
print(newlist)

#1、通过参数索引地址格式化赋值
x = "{} {}".format("hello", "world") # 不设置指定位置，按默认顺序
print(x)#输出 hello,world
x = "{0},{0}".format("hello","world")#制定索引位置
print(x)#输出hello,hello
x = "{0},{1}".format("hello","world")#制定索引位置
print(x)#输出hello,world

#2、通过默认从参数格式化赋值
x = "姓名:{name},年龄:{age},性别:{sex}".format(name="Darker", age="18",sex="男");
print(x)#输出 姓名:Darker,年龄:18,性别:男

#3、按字典的键进行格式化赋值
idict = dict({"name":"Darker","age":"18","sex":"男"})
x = "姓名:{name},年龄:{age},性别:{sex}".format(**idict);
print(x)#输出 姓名:Darker,年龄:18,性别:男

#4、数字格式化 『:.2f』 冒号后面制定精度格式
x = "{:.2f}".format(0.33333333)#待小鼠点
print(x)#输出0.33
x = "{:.0f}".format(0.33333333)#不带小数点
print(x)#输出0，不带小数点会四舍五入

list1 = [1,2,3]
list2 = frozenset(list1)
list1.append(4)#原始集合未冻结，可操作
print(list1)#输出：[1,2,3,4]
#报错：AttributeError: 'frozenset' object has no attribute 'append'
list2.append(5)#list2为冻结集合，不能修改

class Person(object):
    name = "Darker"
    age = 18
    sex = "男"

o = Person()
x = getattr(o,"name")
print(x)#输出Darker
print(getattr(o, "age"))#输出18
setattr(o,"age",28)#重新设置属性值
print(getattr(o,"age"))#输出28

class Person(object):
    name = "Darker"

print(globals())
print(dir())
print(locals())

class Person(object):
    name = "Darker"
obj = Person()
print(hasattr(obj, "name"))#输出True
print(hasattr(obj, "sex"))#输出False

class Person(object):
    name = "Darker"
obj = Person()
print(hash(obj))
print(hash(1))
print(hash("abc"))

help(hash)#输出如下图

#自定义一个类
class Person(object):
    '''
    自定义的一个函数
    '''
    name = "Darker"
    
help(Person)#输出如下图
图片.png 
print(hex(1))#输出：0x1
print(oct(1))#输出：0o1
print(hex(10))#输出 ：0xa
print(oct(10))#输出：0o12

a = "1"
b = 1
d = [1,2,3]
print(id(a))#打印a的地址：30510528
print(id(b))#打印b的地址：1797680144
print(id(d))#打印d的地址：39341128
print(id(d[0]))#打印d[0]的地址： 1797680144
def modify(x):
    x = "10"
    return x
modify(a)#修改a的值
print(id(a))#打印a的地址：30510528
modify(d[0])#修改d[0]的值
print(id(d))#打印d的地址：39341128
print(id(d[0]))#打印d[0]的值： 1797680144

a = "abc"
print(id(a))#30768744

class A:
    pass

 #B继承A
class B(A):
    pass
 
isinstance(A(), A)    # returns True
type(A()) == A        # returns True
isinstance(B(), A)    # returns True
type(B()) == A        # returns False

class A(object):
    pass

class B(A):
    pass

class C(object):
    pass

print(issubclass(B,A))#B是A的继承，输出True
print(issubclass(A,B))#A是B的集成，输出False
print(issubclass(C,A))#C是A的集成，输出False
print(issubclass(C,object))#C是object的继承，输出True

lst = [1, 2, 3]
for i in iter(lst):
    print(i)

lst = [1, 2, 3]
x = "abcd"
print(len(lst))#输出3
print(len(x))#输出4

def mapping(x):
    if x == 1:return "男"
    if x == 0:return "女"
    else: return "未知"
    
lst = [1,2,3,1,3,2,2,1]
x = map(mapping,lst)#次数为一个类，因为mapping中换了返回值的类型
x = list(x)#转化为List
print(x)#输出：['男', '未知', '未知', '男', '未知', '未知', '未知', '男']

print(max([1,2,3]))#输出3
print(min([1,2,3]))#输出1
print(sum([1,2,3]))#输出6
print(pow(2,3))#输出8

v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[0])#输出97
print(v[1])#输出98

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
mode模式 相关描述
t 文本模式 (默认)。
x 写模式，新建一个文件，如果该文件已存在则会报错。
b 二进制模式。
+ 打开一个文件进行更新(可读可写)。
U 通用换行模式（不推荐）。
r 以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb 以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+ 打开一个文件用于读写。文件指针将会放在文件的开头。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w 打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb 以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+ 打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a 打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+ 打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。 
class Parrot(object):
    def __init__(self):
        self._voltage = 100000
 
    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

x = range(5)
print(x)#输出 range(0, 5)
print(list(x))#输出 [0, 1, 2, 3, 4]

返回Python修炼册大纲

上一篇下一篇

猜你喜欢

热点阅读