python入門——函數及python的內置函數

函數

環境介紹：python cmd控制檯和pycharm

python函數的定義

def msg(name):
    print("{}在haha".format(name))
def 函數名稱([參數列表]):
			# 函數體
			# return 返回值

函數的參數問題

• 默認值參數

def get_circle_area(r,pi=3.14):
	pass
默認值參數要放在普通參數後面

• 可變參數

def show(name,age=18,*args):
	pass
args以元組形式保存

• 命名參數

def shows(name,age=18,**kwargs):
	pass
kwargs以字典形式保存

匿名函數

早期，python沒有匿名函數，但可以藉助lambda表達式來使用

def show(fn):
	fn()
show(lambda:print("haha"))#無參情況

def show(fn):
	print(fn)
show(lambda fn:print(fn))#單個參數參情況

def show(fn):
	res = fn(10,20)
	print(fn)
show(lambda x,y:x + y)#多個參數情況
lambda雖然簡化了代碼書寫，增強了代碼維護成本，代碼的可讀性下降了，提升複雜度	

偏函數

將一個函數的某些默認值轉換爲想要的默認值函數

>>> int("123456",base=10)#以十進制讀取，默認也爲10，可修改
123456
>>> int("123456",base=8)#以八進制讀取
42798
>>> int("123456789",base=8)#格式錯誤會報錯
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 8: '123456789'
>>> from functools import partial
>>> partial(int,base=16)			修改int的默認讀取進製爲16
functools.partial(<class 'int'>, base=16)
>>> bs16_int = partial(int,base=16)
>>> bs16_int("ABC")
2748

函數遞歸

函數自身調用自身爲遞歸，必須要有終止條件，否則進入死循環

• 求1-100的和

def get_sum(n):
	#沒有終止條件
	return n + get_sum(n-1)

這樣的代碼就會報錯，python中規定遞歸默認不能超過1000次

 [Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded

設置終止條件

def get_sum(n):
	#有終止條件
	if n == 1:
		return 1
	return n + get_sum(n-1)
res = get_sum(100)
print(res)

python函數的調用

msg("wangcai")
函數名稱([實參列表])

全局函數

python有接近40個全局函數，全局函數的思維導圖在這裏

容器

• tuple 元組
• dict 字典
• list 列表
• set 集合

數據類型

• float 將整數和字符串轉換成浮點數
• int 將一個字符串或數字轉換爲整型
• str 將對象轉化爲適於人閱讀的形式
• chr 用一個範圍在0～255整數作參數，返回一個對應的字符

轉換

• ascii 用ascii碼錶將其轉換爲字符串，若非ascii，如UTF-8字符則有\u前綴進行轉義

>>> ascii("哈哈")
"'\\u54c8\\u54c8'"
>>> a = ascii(33)
>>> type(a)
<class 'str'>

• bin 返回一個整數 int 或者長整數 long int 的二進制表示，類型爲字符串

>>> bin(8)
'0b1000'
>>> a=bin(8)
>>> type(a)
<class 'str'>
>>>

• bool 對值進行布爾運算，None、空字符串、空列表、空元組、空集合、空字典、0等空元素和空數據結構爲False，其他爲True

>>> bool(None),bool(" "),bool(1),bool([]),bool("")
(False, True, True, False, False)

• oct 將整數轉換爲8進制

>>> oct(22)
'0o26'

• ord 以一個字符作爲參數，返回對應的 ASCII 數值或Unicode 值，若超出範圍，則報錯

>>> a="a"
>>> ord(a)
97

• hex 將整數轉換爲16進制

>>> hex(22)
'0x16'
>>> hex(222)
'0xde'

• repr 將對象轉化爲字符串

>>> a = 1998
>>> b="haha"
>>> b+repr(a)
'haha1998'
>>> b+str(a)
'haha1998'

輸入輸出

• input 標準輸入，返回的是字符串

name = input("輸入你的名字:")
print(name)

輸入你的名字:翠花
翠花

• print 輸出流

print("哈哈")
哈哈

其它

• abs 求數的絕對值，若數爲複數，則返回模

>>> abs(-17),abs(3+4j)
(17, 5.0)

• all 可迭代對象所有元素爲True則返回True，否則返回False

>>> all([1, 3, " "]), all([1, 3, None])#空格也是一個有效字符
(True, False)

• any 可迭代對象所有元素爲False則返回False，否則返回True

>>> any([1, 3,None]), all([None, None])
(True, False)

• bytearray 返回新的二進制數組，擁有列表大多數方法，這個是存放二進制數據，添加數據需要輸入整數，參數範圍爲(0, 256)

a = bytearray("哈哈",encoding="utf-8")
print(a,type(a))

bytearray(b'\xe5\x93\x88\xe5\x93\x88') <class 'bytearray'>

• bytes 返回一個新的bytes對象，範圍是0-256區間的整數不可變序列

>>> bytes("翠花", encoding="utf-8")
b'\xe7\xbf\xa0\xe8\x8a\xb1'

• callable 判斷對象是否可調用

class CuiHua:
    def __call__(self):
        print("Hello,翠花")
print(callable(CuiHua))

True

• classmethod 不需要實例化和self 參數，但第一個參數需要是表示自身類的 cls 參數，可以來調用類的屬性，方法和實例化對象

class A():
    bar = 1

    @classmethod
    def func1(cls):
        print('func1')
        print(cls.bar)

A.func2()

• compile 將一個字符串編譯爲字節代碼

str = "3 * 4"
a = compile(str,'','eval')
print(eval(a))
結果：12

• complex 返回一個複數，值爲 real + imag * j 的複數或者轉化一個字符串或數爲複數。如果第一個參數爲字符串，則不需要指定第二個參數

>>> complex("3+4j"),complex(3,4)
((3+4j), (3+4j))

• delattr 刪除對象的一個實例屬性

class CuiHua:
    def __init__(self, name, age):
        self.name = name
        self.age = age

Cui = CuiHua("翠花", 18)
print(Cui.name)
# 刪除對象中的屬性
delattr(Cui, "name")
print(Cui.name) 

• dir 不帶參數時，返回當前範圍內的變量、方法和定義的類型列表;帶參數時，返回參數的屬性、方法列表

>>> dir()
['A', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']

• divmod 返回整除整數a//b和餘數a%b

>>> divmod(15,2)
(7, 1)

• enumerate 返回一個枚舉對象，start可以指定枚舉計數，默認爲0

>>> a = enumerate("哈哈",start=1)
>>> a,type(a)
(<enumerate object at 0x030C2E90>, <class 'enumerate'>)

• eval 運行字符串代碼，返回傳入字符串的表達式的結果，不改變源碼邏輯

>>> eval("1+3*(6+1)*5")
106

• exec 運行字符串代碼，改變源碼邏輯

>>> sum = 0
>>> exec("sum += 1")
>>> sum
1

• filter 依次取出可迭代對象中元素交給一個函數，取返回True的元素

a = [-1,-2,-3,-4,0,1,2,3,4]

def is_natural(number):
    """判斷是否是自然數"""
    if isinstance(number, int) and number >= 0:
        return True
    else:
        return False

# 返回filter對象
result = filter(is_natural,a)
print(list(result))

[0, 1, 2, 3, 4]

• format 格式化字符串

age = 18
print("翠花的年齡是{}".format(age))
翠花的年齡是18

• frozenset 返回一個凍結的集合，凍結後集合不能再添加或刪除任何元素

>>> a = {1,2,3,4}
>>> b = frozenset(a)
>>> a
{1, 2, 3, 4}
>>> b
frozenset({1, 2, 3, 4})

• globals 以字典類型返回當前位置的全部全局變量

>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}

• getattr 通過字符串獲取對象屬性和方法值，一般聯合hasattr使用

class CuiHua:

    def hello(self):
        print("Hello, 翠花")

Cui = CuiHua()
print(getattr(Cui, 'hello', None))

• hasattr 判斷對象中是否有對應字符串的屬性和方法

class CuiHua:

    def hello(self):
        print("Hello, 翠花")

Cui = CuiHua()
if hasattr(Cui, "hello"):
    getattr(Cui, "hello")()

• setattr 對應函數 getattr()，用於設置屬性值，該屬性可以不存在

class A():
    haha = 1

a = A()
print(getattr(a,'haha'))
setattr(a,'haha',10)
print(a.haha)
結果：	1
		10

• hash 返回對象的hash值

>>> hash("222")
-1471210590

• help 獲取方法名和方法名下面的註釋

>>> help(hash)
Help on built-in function hash in module builtins:

hash(obj, /)
    Return the hash value for the given object.

    Two objects that compare equal must also have the same hash value, but the
    reverse is not necessarily true.

• id 以10進制獲取對象內存地址

>>> a = 123
>>> id(a)
2088922112

• isinstance 判斷對象是否是某種或多個類型，判斷對象是否繼承某個類

def is_natural(number):
    """判斷是否是自然數"""
    if isinstance(number, int) and number >= 0:
        return True
    else:
        return False

• issubclass 判斷類是否是某個類的子類，注意：左邊爲要判斷的子類，右邊爲父類

class Dog:
    pass

class JingBa(Dog):
    pass

print(issubclass(Dog,JingBa))
print(issubclass(JingBa,Dog))

False
True

• iter 生成迭代器

list = iter([1,2,3,4])
for i in list:
    print(i)
結果：
1 
2 
3 
4

• len 獲取對象長度

>>> a = [1,2,3,4]
>>> len(a)
4

• locals 以字典類型返回當前位置的全部局部變量

>>> def A(x):
...     z=1
...     print(locals())
...
>>> A(10)
{'x': 10, 'z': 1}

• map 將可迭代對象依次傳入函數，返回可迭代對象

>>> def A(x) :
...     return x*x
...
>>> map(A,[1,2,3,4,5])
<map object at 0x006D8C50>

• max 最大值
• min 最小值
• memoryview 返回給定參數的內存查看對象（內存查看對象，是指對支持緩衝區協議的數據進行包裝，在不需要複製對象基礎上允許代碼訪問）

>>>a = memoryview(bytearray("abcefg", 'utf-8'))
>>> print(a[1])
98
>>> print(a[-1])
103

• next 返回迭代器的下一個項目

list = iter([1,2,3,4])
while True:
    x = next(list)
    print(x)
    if x == 4:
        break
結果：
1 
2 
3 
4

• object python的默認類，python3種默認都是新式類，基類都會繼承object類

def A(object):
	pass

• open 打開一個文件並返回文件對象

f = open("e://a.txt","r")

• pow 返回 x ^ y 或 返回 x ^ y % z的值

>>> pow(2,3)
8
>>> pow(2,3,3)
2

• property 在新式類中返回屬性值

class C(object):
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

• reload 重新載入之前載入的模塊

import  sys
....
reload(sys)

• range 不可變數據序列，有三個參數開始start, 停止stop,步長step

for i in range(1, 10, 2):
    print(i)
1 3 5 7 9

• reversed 用於反向列表

>>> a= [0,1,2,3,4]
>>> a.reverse()
>>> a
[4, 3, 2, 1, 0]

• round 四捨五入保留多少小數位

>>> round(3.141592657,2)
3.14
>>> round(3.141592657,5)
3.14159

• slice 切片操作函數裏的參數傳遞 slice(start,stop,step)

>>> a = slice(0,100,3)
>>> list = [0,1,2,3,4,5,6,7,8,9,10]
>>> list[a]
[0, 3, 6, 9]

• sorted 將可迭代對象進行排序

>>> list = [10,11,22,53,64,5,6,7,8,9,10]
>>> sorted(list)
[5, 6, 7, 8, 9, 10, 10, 11, 22, 53, 64]

• sum 序列求和

>>> sum([1,2,3,4,5])
15

• super 調用父類方法

class Person:
	def __init__(self, name, language):
        self.name = name
        self.language = language
class Richman(Person):
    def __init__(self):
        super().__init__(name,language)

• type 返回對象是由什麼類型構建的

>>> type("haha")
<class 'str'>
>>> type([1,2,3])
<class 'list'>

• vars 獲取具有字典屬性的對象

def CuiHua():
    name = "翠花"
    age = 18
    print(vars())

CuiHua()

{'name': '翠花', 'age': 18}

• zip 依次取出可迭代對象中元素組成新的元組，返回一個迭代器

a = zip("cuihua", "翠花")
print(a.__next__())
print(a.__next__())

('c', '翠')
('u', '花')