成都創(chuàng)新互聯(lián)公司是一家集網(wǎng)站建設(shè),榮成企業(yè)網(wǎng)站建設(shè),榮成品牌網(wǎng)站建設(shè),網(wǎng)站定制,榮成網(wǎng)站建設(shè)報價,網(wǎng)絡(luò)營銷,網(wǎng)絡(luò)優(yōu)化,榮成網(wǎng)站推廣為一體的創(chuàng)新建站企業(yè)，幫助傳統(tǒng)企業(yè)提升企業(yè)形象加強企業(yè)競爭力?？沙浞譂M足這一群體相比中小企業(yè)更為豐富、高端、多元的互聯(lián)網(wǎng)需求。同時我們時刻保持專業(yè)、時尚、前沿，時刻以成就客戶成長自我，堅持不斷學(xué)習(xí)、思考、沉淀、凈化自己，讓我們?yōu)楦嗟钠髽I(yè)打造出實用型網(wǎng)站。
點擊上方 "Python人工智能技術(shù)" 關(guān)注，星標(biāo)或者置頂
22點24分準(zhǔn)時推送，第一時間送達(dá)
后臺回復(fù)“大禮包”，送你特別福利
編輯：樂樂 | 來自：pypypypy
上一篇：
正文
大家好，我是Pythn人工智能技術(shù)。
內(nèi)置函數(shù)就是Python給你提供的，拿來直接用的函數(shù)，比如print.，input等。
截止到python版本3.6.2 ，python一共提供了68個內(nèi)置函數(shù)，具體如下
abs() dict() help() min() setattr()
all() dir() hex() next() slice()
any() divmod() id() object() sorted()
ascii() enumerate() input() oct() staticmethod()
bin() eval() int() open() str()
bool() exec() isinstance() ord() sum()
bytearray() ?lter() issubclass() pow() super()
bytes() ?oat() iter() print() tuple()
callable() format() len() property() type()
chr() frozenset() list() range() vars()
classmethod() getattr() locals() repr() zip()
compile() globals() map() reversed() __import__()
complex() hasattr() max() round()
delattr() hash() memoryview() set()
本文將這68個內(nèi)置函數(shù)綜合整理為12大類，正在學(xué)習(xí)Python基礎(chǔ)的讀者一定不要錯過，建議收藏學(xué)習(xí)！
和數(shù)字相關(guān) 1. 數(shù)據(jù)類型
bool : 布爾型(True,False)
int : 整型(整數(shù))
float : 浮點型(小數(shù))
complex : 復(fù)數(shù)
2. 進(jìn)制轉(zhuǎn)換
bin() 將給的參數(shù)轉(zhuǎn)換成二進(jìn)制
otc() 將給的參數(shù)轉(zhuǎn)換成八進(jìn)制
hex() 將給的參數(shù)轉(zhuǎn)換成十六進(jìn)制
print(bin(10)) # 二進(jìn)制:0b1010
print(hex(10)) # 十六進(jìn)制:0xa
print(oct(10)) # 八進(jìn)制:0o12
3. 數(shù)學(xué)運算
abs() 返回絕對值
divmode() 返回商和余數(shù)
round() 四舍五入
pow(a, b) 求a的b次冪, 如果有三個參數(shù). 則求完次冪后對第三個數(shù)取余
sum() 求和
min() 求最小值
max() 求最大值
print(abs(-2)) # 絕對值:2
print(divmod(20,3)) # 求商和余數(shù):(6,2)
print(round(4.50)) # 五舍六入:4
print(round(4.51)) #5
print(pow(10,2,3)) # 如果給了第三個參數(shù). 表示最后取余:1
print(sum([1,2,3,4,5,6,7,8,9,10])) # 求和:55
print(min(5,3,9,12,7,2)) #求最小值:2
print(max(7,3,15,9,4,13)) #求最大值:15
和數(shù)據(jù)結(jié)構(gòu)相關(guān) 1. 序列
（1）列表和元組
list() 將一個可迭代對象轉(zhuǎn)換成列表
tuple() 將一個可迭代對象轉(zhuǎn)換成元組
print(list((1,2,3,4,5,6))) #[1, 2, 3, 4, 5, 6]
print(tuple([1,2,3,4,5,6])) #(1, 2, 3, 4, 5, 6)
（2）相關(guān)內(nèi)置函數(shù)
reversed() 將一個序列翻轉(zhuǎn), 返回翻轉(zhuǎn)序列的迭代器
slice() 列表的切片
lst = "你好啊"
it = reversed(lst) # 不會改變原列表. 返回一個迭代器, 設(shè)計上的一個規(guī)則
print(list(it)) #['啊', '好', '你']
lst = [1, 2, 3, 4, 5, 6, 7]
print(lst[1:3:1]) #[2,3]
s = slice(1, 3, 1) # 切片用的
print(lst[s]) #[2,3]
（3）字符串
str() 將數(shù)據(jù)轉(zhuǎn)化成字符串
print(str(123)+'456') #123456
format() 與具體數(shù)據(jù)相關(guān), 用于計算各種小數(shù), 精算等.
s = "hello world!"
print(format(s, "^20")) #劇中
print(format(s, "20")) #左對齊
print(format(s, "20")) #右對齊
# hello world!
# hello world!
# hello world!
print(format(3, 'b' )) # 二進(jìn)制:11
print(format(97, 'c' )) # 轉(zhuǎn)換成unicode字符:a
print(format(11, 'd' )) # ?進(jìn)制:11
print(format(11, 'o' )) # 八進(jìn)制:13
print(format(11, 'x' )) # 十六進(jìn)制(?寫字母):b
print(format(11, 'X' )) # 十六進(jìn)制(大寫字母):B
print(format(11, 'n' )) # 和d?樣:11
print(format(11)) # 和d?樣:11
print(format(123456789, 'e' )) # 科學(xué)計數(shù)法. 默認(rèn)保留6位小數(shù):1.234568e+08
print(format(123456789, '0.2e' )) # 科學(xué)計數(shù)法. 保留2位小數(shù)(小寫):1.23e+08
print(format(123456789, '0.2E' )) # 科學(xué)計數(shù)法. 保留2位小數(shù)(大寫):1.23E+08
print(format(1.23456789, 'f' )) # 小數(shù)點計數(shù)法. 保留6位小數(shù):1.234568
print(format(1.23456789, '0.2f' )) # 小數(shù)點計數(shù)法. 保留2位小數(shù):1.23
print(format(1.23456789, '0.10f')) # 小數(shù)點計數(shù)法. 保留10位小數(shù):1.2345678900
print(format(1.23456789e+3, 'F')) # 小數(shù)點計數(shù)法. 很大的時候輸出INF:1234.567890
bytes() 把字符串轉(zhuǎn)化成bytes類型
bs = bytes("今天吃飯了嗎", encoding="utf-8")
print(bs) #b'\xe4\xbb\x8a\xe5\xa4\xa9\xe5\x90\x83\xe9\xa5\xad\xe4\xba\x86\xe5\x90\x97'
bytearray() 返回一個新字節(jié)數(shù)組. 這個數(shù)字的元素是可變的, 并且每個元素的值得范圍是[0,256)
ret = bytearray("alex" ,encoding ='utf-8')
print(ret[0]) #97
print(ret) #bytearray(b'alex')
ret[0] = 65 #把65的位置A賦值給ret[0]
print(str(ret)) #bytearray(b'Alex')
ord() 輸入字符找?guī)ё址幋a的位置
chr() 輸入位置數(shù)字找出對應(yīng)的字符
ascii() 是ascii碼中的返回該值 不是就返回u
print(ord('a')) # 字母a在編碼表中的碼位:97
print(ord('中')) # '中'字在編碼表中的位置:20013
print(chr(65)) # 已知碼位,求字符是什么:A
print(chr(19999)) #丟
for i in range(65536): #打印出0到65535的字符
print(chr(i), end=" ")
print(ascii("@")) #'@'
repr() 返回一個對象的string形式
s = "今天\n吃了%s頓\t飯" % 3
print(s)#今天# 吃了3頓 飯
print(repr(s)) # 原樣輸出,過濾掉轉(zhuǎn)義字符 \n \t \r 不管百分號%
#'今天\n吃了3頓\t飯'
2. 數(shù)據(jù)集合
字典：dict 創(chuàng)建一個字典
集合：set 創(chuàng)建一個集合
frozenset() 創(chuàng)建一個凍結(jié)的集合，凍結(jié)的集合不能進(jìn)行添加和刪除操作。
3. 相關(guān)內(nèi)置函數(shù)
len() 返回一個對象中的元素的個數(shù)
sorted() 對可迭代對象進(jìn)行排序操作 (lamda)
語法：sorted(Iterable, key=函數(shù)(排序規(guī)則), reverse=False)
Iterable: 可迭代對象
key: 排序規(guī)則(排序函數(shù)), 在sorted內(nèi)部會將可迭代對象中的每一個元素傳遞給這個函數(shù)的參數(shù). 根據(jù)函數(shù)運算的結(jié)果進(jìn)行排序
reverse: 是否是倒敘. True: 倒敘, False: 正序
lst = [5,7,6,12,1,13,9,18,5]
lst.sort() # sort是list里面的一個方法
print(lst) #[1, 5, 5, 6, 7, 9, 12, 13, 18]
ll = sorted(lst) # 內(nèi)置函數(shù). 返回給你一個新列表 新列表是被排序的
print(ll) #[1, 5, 5, 6, 7, 9, 12, 13, 18]
l2 = sorted(lst,reverse=True) #倒序
print(l2) #[18, 13, 12, 9, 7, 6, 5, 5, 1]
#根據(jù)字符串長度給列表排序
lst = ['one', 'two', 'three', 'four', 'five', 'six']
def f(s):
return len(s)
l1 = sorted(lst, key=f, )
print(l1) #['one', 'two', 'six', 'four', 'five', 'three']
enumerate() 獲取集合的枚舉對象
lst = ['one','two','three','four','five']
for index, el in enumerate(lst,1): # 把索引和元素一起獲取,索引默認(rèn)從0開始. 可以更改
print(index)
print(el)
# 1
# one
# 2
# two
# 3
# three
# 4
# four
# 5
# five
all() 可迭代對象中全部是True, 結(jié)果才是True
any() 可迭代對象中有一個是True, 結(jié)果就是True
print(all([1,'hello',True,9])) #True
print(any([0,0,0,False,1,'good'])) #True
zip() 函數(shù)用于將可迭代的對象作為參數(shù), 將對象中對應(yīng)的元素打包成一個元組, 然后返回由這些元組組成的列表. 如果各個迭代器的元素個數(shù)不一致, 則返回列表長度與最短的對象相同
lst1 = [1, 2, 3, 4, 5, 6]
lst2 = ['醉鄉(xiāng)民謠', '驢得水', '放牛班的春天', '美麗人生', '辯護人', '被嫌棄的松子的一生']
lst3 = ['美國', '中國', '法國', '意大利', '韓國', '日本']
print(zip(lst1, lst1, lst3)) #
for el in zip(lst1, lst2, lst3):
print(el)
# (1, '醉鄉(xiāng)民謠', '美國')
# (2, '驢得水', '中國')
# (3, '放牛班的春天', '法國')
# (4, '美麗人生', '意大利')
# (5, '辯護人', '韓國')
# (6, '被嫌棄的松子的一生', '日本')
fiter() 過濾 (lamda)
語法：fiter(function. Iterable)
function: 用來篩選的函數(shù). 在?lter中會自動的把iterable中的元素傳遞給function. 然后根據(jù)function返回的True或者False來判斷是否保留留此項數(shù)據(jù) , Iterable: 可迭代對象
搜索公眾號頂級架構(gòu)師后臺回復(fù)“面試”，送你一份驚喜禮包。
def func(i): # 判斷奇數(shù)
return i % 2 == 1
lst = [1,2,3,4,5,6,7,8,9]
l1 = filter(func, lst) #l1是迭代器
print(l1) #
print(list(l1)) #[1, 3, 5, 7, 9]
map() 會根據(jù)提供的函數(shù)對指定序列列做映射(lamda)
語法 : map(function, iterable)
可以對可迭代對象中的每一個元素進(jìn)行映射. 分別去執(zhí)行 function
def f(i): return i
lst = [1,2,3,4,5,6,7,]
it = map(f, lst) # 把可迭代對象中的每一個元素傳遞給前面的函數(shù)進(jìn)行處理. 處理的結(jié)果會返回成迭代器print(list(it)) #[1, 2, 3, 4, 5, 6, 7]
和作用域相關(guān)
locals() 返回當(dāng)前作用域中的名字
globals() 返回全局作用域中的名字
def func():
a = 10
print(locals()) # 當(dāng)前作用域中的內(nèi)容
print(globals()) # 全局作用域中的內(nèi)容
print("今天內(nèi)容很多")
func()
# {'a': 10}
# {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__':
# _frozen_importlib_external.SourceFileLoader object at 0x0000026F8D566080,
# '__spec__': None, '__annotations__': {}, '__builtins__':
# (built-in), '__file__': 'D:/pycharm/練習(xí)/week03/new14.py', '__cached__': None,
# 'func': }
# 今天內(nèi)容很多
和迭代器生成器相關(guān)
range() 生成數(shù)據(jù)
next() 迭代器向下執(zhí)行一次, 內(nèi)部實際使?用了__ next__()?方法返回迭代器的下一個項目
iter() 獲取迭代器, 內(nèi)部實際使用的是__ iter__()?方法來獲取迭代器
for i in range(15,-1,-5):
print(i)
# 15
# 10
# 5
# 0
lst = [1,2,3,4,5]
it = iter(lst) # __iter__()獲得迭代器
print(it.__next__()) #1
print(next(it)) #2 __next__()
print(next(it)) #3
print(next(it)) #4
字符串類型代碼的執(zhí)行
eval() 執(zhí)行字符串類型的代碼. 并返回最終結(jié)果
exec() 執(zhí)行字符串類型的代碼
compile() 將字符串類型的代碼編碼. 代碼對象能夠通過exec語句來執(zhí)行或者eval()進(jìn)行求值
s1 = input("請輸入a+b:") #輸入:8+9
print(eval(s1)) # 17 可以動態(tài)的執(zhí)行代碼. 代碼必須有返回值
s2 = "for i in range(5): print(i)"
a = exec(s2) # exec 執(zhí)行代碼不返回任何內(nèi)容
# 0
# 1
# 2
# 3
# 4
print(a) #None
# 動態(tài)執(zhí)行代碼
exec("""
def func():
print(" 我是周杰倫")
""" )
func() #我是周杰倫
code1 = "for i in range(3): print(i)"
com = compile(code1, "", mode="exec") # compile并不會執(zhí)行你的代碼.只是編譯
exec(com) # 執(zhí)行編譯的結(jié)果
# 0
# 1
# 2
code2 = "5+6+7"
com2 = compile(code2, "", mode="eval")
print(eval(com2)) # 18
code3 = "name = input('請輸入你的名字:')" #輸入:hello
com3 = compile(code3, "", mode="single")
exec(com3)
print(name) #hello
輸入輸出
print() : 打印輸出
input() : 獲取用戶輸出的內(nèi)容
print("hello", "world", sep="*", end="@") # sep:打印出的內(nèi)容用什么連接,end:以什么為結(jié)尾
#hello*world@
內(nèi)存相關(guān)
hash() : 獲取到對象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空間換的時間 比較耗費內(nèi)存
s = 'alex'print(hash(s)) #-168324845050430382lst = [1, 2, 3, 4, 5]print(hash(lst)) #報錯,列表是不可哈希的 id() : 獲取到對象的內(nèi)存地址s = 'alex'print(id(s)) #2278345368944
文件操作相關(guān)
open() : 用于打開一個文件, 創(chuàng)建一個文件句柄
f = open('file',mode='r',encoding='utf-8')
f.read()
f.close()
模塊相關(guān)
__ import__() : 用于動態(tài)加載類和函數(shù)
# 讓用戶輸入一個要導(dǎo)入的模塊
import os
name = input("請輸入你要導(dǎo)入的模塊:")
__import__(name) # 可以動態(tài)導(dǎo)入模塊
幫 助
help() : 函數(shù)用于查看函數(shù)或模塊用途的詳細(xì)說明
print(help(str)) #查看字符串的用途
調(diào)用相關(guān)
callable() : 用于檢查一個對象是否是可調(diào)用的. 如果返回True, object有可能調(diào)用失敗, 但如果返回False. 那調(diào)用絕對不會成功
a = 10
print(callable(a)) #False 變量a不能被調(diào)用
def f():
print("hello")
print(callable(f)) # True 函數(shù)是可以被調(diào)用的
查看內(nèi)置屬性
dir() : 查看對象的內(nèi)置屬性, 訪問的是對象中的__dir__()方法
print(dir(tuple)) #查看元組的方法
你還有什么想要補充的嗎？
免責(zé)聲明：本文內(nèi)容來源于網(wǎng)絡(luò)，文章版權(quán)歸原作者所有，意在傳播相關(guān)技術(shù)知識行業(yè)趨勢，供大家學(xué)習(xí)交流，若涉及作品版權(quán)問題，請聯(lián)系刪除或授權(quán)事宜。
技術(shù)君個人微信
添加技術(shù)君個人微信即送一份驚喜大禮包
→ 技術(shù)資料共享
→ 技術(shù)交流社群
--END--
往日熱文：
Python程序員深度學(xué)習(xí)的“四大名著”：
這四本書著實很不錯！我們都知道現(xiàn)在機器學(xué)習(xí)、深度學(xué)習(xí)的資料太多了，面對海量資源，往往陷入到“無從下手”的困惑出境。而且并非所有的書籍都是優(yōu)質(zhì)資源，浪費大量的時間是得不償失的。給大家推薦這幾本好書并做簡單介紹。
獲得方式：
2.后臺回復(fù)關(guān)鍵詞：名著
Python 函數(shù)
函數(shù)是組織好的，可重復(fù)使用的，用來實現(xiàn)單一，或相關(guān)聯(lián)功能的代碼段。
函數(shù)能提高應(yīng)用的模塊性，和代碼的重復(fù)利用率。你已經(jīng)知道Python提供了許多內(nèi)建函數(shù)，比如print()。但你也可以自己創(chuàng)建函數(shù)，這被叫做用戶自定義函數(shù)。
定義一個函數(shù)
你可以定義一個由自己想要功能的函數(shù)，以下是簡單的規(guī)則：
函數(shù)代碼塊以?def?關(guān)鍵詞開頭，后接函數(shù)標(biāo)識符名稱和圓括號()。
任何傳入?yún)?shù)和自變量必須放在圓括號中間。圓括號之間可以用于定義參數(shù)。
函數(shù)的第一行語句可以選擇性地使用文檔字符串—用于存放函數(shù)說明。
函數(shù)內(nèi)容以冒號起始，并且縮進(jìn)。
return [表達(dá)式]?結(jié)束函數(shù)，選擇性地返回一個值給調(diào)用方。不帶表達(dá)式的return相當(dāng)于返回 None。
語法
def functionname( parameters ): ? "函數(shù)_文檔字符串"
function_suite
return [expression]
默認(rèn)情況下，參數(shù)值和參數(shù)名稱是按函數(shù)聲明中定義的順序匹配起來的。
實例
以下為一個簡單的Python函數(shù)，它將一個字符串作為傳入?yún)?shù)，再打印到標(biāo)準(zhǔn)顯示設(shè)備上。
實例(Python 2.0+)
def printme( str ): ? "打印傳入的字符串到標(biāo)準(zhǔn)顯示設(shè)備上"
print str
return
函數(shù)調(diào)用
定義一個函數(shù)只給了函數(shù)一個名稱，指定了函數(shù)里包含的參數(shù)，和代碼塊結(jié)構(gòu)。
這個函數(shù)的基本結(jié)構(gòu)完成以后，你可以通過另一個函數(shù)調(diào)用執(zhí)行，也可以直接從Python提示符執(zhí)行。
如下實例調(diào)用了printme（）函數(shù)：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 定義函數(shù)def printme( str ): ? "打印任何傳入的字符串"
print str
return
# 調(diào)用函數(shù)printme("我要調(diào)用用戶自定義函數(shù)!")printme("再次調(diào)用同一函數(shù)")
以上實例輸出結(jié)果：
我要調(diào)用用戶自定義函數(shù)!再次調(diào)用同一函數(shù)
參數(shù)傳遞
在 python 中，類型屬于對象，變量是沒有類型的：
a=[1,2,3]
a="Runoob"
以上代碼中，[1,2,3]?是 List 類型，"Runoob"?是 String 類型，而變量 a 是沒有類型，她僅僅是一個對象的引用（一個指針），可以是 List 類型對象，也可以指向 String 類型對象。
可更改(mutable)與不可更改(immutable)對象
在 python 中，strings, tuples, 和 numbers 是不可更改的對象，而 list,dict 等則是可以修改的對象。
不可變類型：變量賦值?a=5?后再賦值?a=10，這里實際是新生成一個 int 值對象 10，再讓 a 指向它，而 5 被丟棄，不是改變a的值，相當(dāng)于新生成了a。
可變類型：變量賦值?la=[1,2,3,4]?后再賦值?la[2]=5?則是將 list la 的第三個元素值更改，本身la沒有動，只是其內(nèi)部的一部分值被修改了。
python 函數(shù)的參數(shù)傳遞：
不可變類型：類似 c++ 的值傳遞，如 整數(shù)、字符串、元組。如fun（a），傳遞的只是a的值，沒有影響a對象本身。比如在 fun（a）內(nèi)部修改 a 的值，只是修改另一個復(fù)制的對象，不會影響 a 本身。
可變類型：類似 c++ 的引用傳遞，如 列表，字典。如 fun（la），則是將 la 真正的傳過去，修改后fun外部的la也會受影響
python 中一切都是對象，嚴(yán)格意義我們不能說值傳遞還是引用傳遞，我們應(yīng)該說傳不可變對象和傳可變對象。
python 傳不可變對象實例
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
def ChangeInt( a ): ? ?a = 10
b = 2ChangeInt(b)print b # 結(jié)果是 2
實例中有 int 對象 2，指向它的變量是 b，在傳遞給 ChangeInt 函數(shù)時，按傳值的方式復(fù)制了變量 b，a 和 b 都指向了同一個 Int 對象，在 a=10 時，則新生成一個 int 值對象 10，并讓 a 指向它。
傳可變對象實例
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數(shù)說明def changeme( mylist ): ? "修改傳入的列表"
mylist.append([1,2,3,4])
print "函數(shù)內(nèi)取值: ", mylist
return
# 調(diào)用changeme函數(shù)mylist = [10,20,30]changeme( mylist )print "函數(shù)外取值: ", mylist
實例中傳入函數(shù)的和在末尾添加新內(nèi)容的對象用的是同一個引用，故輸出結(jié)果如下：
函數(shù)內(nèi)取值: ?[10, 20, 30, [1, 2, 3, 4]]函數(shù)外取值: ?[10, 20, 30, [1, 2, 3, 4]]
參數(shù)
以下是調(diào)用函數(shù)時可使用的正式參數(shù)類型：
必備參數(shù)
關(guān)鍵字參數(shù)
默認(rèn)參數(shù)
不定長參數(shù)
必備參數(shù)
必備參數(shù)須以正確的順序傳入函數(shù)。調(diào)用時的數(shù)量必須和聲明時的一樣。
調(diào)用printme()函數(shù)，你必須傳入一個參數(shù)，不然會出現(xiàn)語法錯誤：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數(shù)說明def printme( str ): ? "打印任何傳入的字符串"
print str
return
#調(diào)用printme函數(shù)printme()
以上實例輸出結(jié)果：
Traceback (most recent call last):
File "test.py", line 11, in module
printme()TypeError: printme() takes exactly 1 argument (0 given)
關(guān)鍵字參數(shù)
關(guān)鍵字參數(shù)和函數(shù)調(diào)用關(guān)系緊密，函數(shù)調(diào)用使用關(guān)鍵字參數(shù)來確定傳入的參數(shù)值。
使用關(guān)鍵字參數(shù)允許函數(shù)調(diào)用時參數(shù)的順序與聲明時不一致，因為 Python 解釋器能夠用參數(shù)名匹配參數(shù)值。
以下實例在函數(shù) printme() 調(diào)用時使用參數(shù)名：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數(shù)說明def printme( str ): ? "打印任何傳入的字符串"
print str
return
#調(diào)用printme函數(shù)printme( str = "My string")
以上實例輸出結(jié)果：
My string
下例能將關(guān)鍵字參數(shù)順序不重要展示得更清楚：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數(shù)說明def printinfo( name, age ): ? "打印任何傳入的字符串"
print "Name: ", name
print "Age ", age
return
#調(diào)用printinfo函數(shù)printinfo( age=50, name="miki" )
以上實例輸出結(jié)果：
Name: ?mikiAge ?50
默認(rèn)參數(shù)
調(diào)用函數(shù)時，默認(rèn)參數(shù)的值如果沒有傳入，則被認(rèn)為是默認(rèn)值。下例會打印默認(rèn)的age，如果age沒有被傳入：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
#可寫函數(shù)說明def printinfo( name, age = 35 ): ? "打印任何傳入的字符串"
print "Name: ", name
print "Age ", age
return
#調(diào)用printinfo函數(shù)printinfo( age=50, name="miki" )printinfo( name="miki" )
以上實例輸出結(jié)果：
Name: ?mikiAge ?50Name: ?mikiAge ?35
不定長參數(shù)
你可能需要一個函數(shù)能處理比當(dāng)初聲明時更多的參數(shù)。這些參數(shù)叫做不定長參數(shù)，和上述2種參數(shù)不同，聲明時不會命名?；菊Z法如下：
def functionname([formal_args,] *var_args_tuple ): ? "函數(shù)_文檔字符串"
function_suite
return [expression]
加了星號（*）的變量名會存放所有未命名的變量參數(shù)。不定長參數(shù)實例如下：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數(shù)說明def printinfo( arg1, *vartuple ): ? "打印任何傳入的參數(shù)"
print "輸出: "
print arg1
for var in vartuple: ? ? ?print var
return
# 調(diào)用printinfo 函數(shù)printinfo( 10 )printinfo( 70, 60, 50 )
以上實例輸出結(jié)果：
輸出:10輸出:706050
匿名函數(shù)
python 使用 lambda 來創(chuàng)建匿名函數(shù)。
lambda只是一個表達(dá)式，函數(shù)體比def簡單很多。
lambda的主體是一個表達(dá)式，而不是一個代碼塊。僅僅能在lambda表達(dá)式中封裝有限的邏輯進(jìn)去。
lambda函數(shù)擁有自己的命名空間，且不能訪問自有參數(shù)列表之外或全局命名空間里的參數(shù)。
雖然lambda函數(shù)看起來只能寫一行，卻不等同于C或C++的內(nèi)聯(lián)函數(shù)，后者的目的是調(diào)用小函數(shù)時不占用棧內(nèi)存從而增加運行效率。
語法
lambda函數(shù)的語法只包含一個語句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
如下實例：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數(shù)說明sum = lambda arg1, arg2: arg1 + arg2
# 調(diào)用sum函數(shù)print "相加后的值為 : ", sum( 10, 20 )print "相加后的值為 : ", sum( 20, 20 )
以上實例輸出結(jié)果：
相加后的值為 : ?30相加后的值為 : ?40
return 語句
return語句[表達(dá)式]退出函數(shù)，選擇性地向調(diào)用方返回一個表達(dá)式。不帶參數(shù)值的return語句返回None。之前的例子都沒有示范如何返回數(shù)值，下例便告訴你怎么做：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
# 可寫函數(shù)說明def sum( arg1, arg2 ): ? # 返回2個參數(shù)的和."
total = arg1 + arg2
print "函數(shù)內(nèi) : ", total
return total
# 調(diào)用sum函數(shù)total = sum( 10, 20 )
以上實例輸出結(jié)果：
函數(shù)內(nèi) : ?30
變量作用域
一個程序的所有的變量并不是在哪個位置都可以訪問的。訪問權(quán)限決定于這個變量是在哪里賦值的。
變量的作用域決定了在哪一部分程序你可以訪問哪個特定的變量名稱。兩種最基本的變量作用域如下：
全局變量
局部變量
全局變量和局部變量
定義在函數(shù)內(nèi)部的變量擁有一個局部作用域，定義在函數(shù)外的擁有全局作用域。
局部變量只能在其被聲明的函數(shù)內(nèi)部訪問，而全局變量可以在整個程序范圍內(nèi)訪問。調(diào)用函數(shù)時，所有在函數(shù)內(nèi)聲明的變量名稱都將被加入到作用域中。如下實例：
實例(Python 2.0+)
#!/usr/bin/python# -*- coding: UTF-8 -*-
total = 0 # 這是一個全局變量# 可寫函數(shù)說明def sum( arg1, arg2 ): ? #返回2個參數(shù)的和."
total = arg1 + arg2 # total在這里是局部變量.
print "函數(shù)內(nèi)是局部變量 : ", total
return total
#調(diào)用sum函數(shù)sum( 10, 20 )print "函數(shù)外是全局變量 : ", total
以上實例輸出結(jié)果：
函數(shù)內(nèi)是局部變量 : ?30函數(shù)外是全局變量 : ?0
python常見的內(nèi)置函數(shù)有：
1. abs()函數(shù)返回數(shù)字的絕對值。
2. all() 函數(shù)用于判斷給定的參數(shù)中的所有元素是否都為 TRUE，如果是返回 True，否則返回 False。元素除了是 0、空、None、False 外都算 True；空元組、空列表返回值為True。
3. any() 函數(shù)用于判斷給定的參數(shù)是否全部為False，是則返回False，如果有一個為True，則返回True。 元素除了是 0、空、False外都算 TRUE。
4. bin()函數(shù)返回一個整數(shù)int或者長整數(shù)long int的二進(jìn)制表示。
5. bool() 函數(shù)用于將給定參數(shù)轉(zhuǎn)換為布爾類型，如果參數(shù)不為空或不為0，返回True；參數(shù)為0或沒有參數(shù)，返回False。
6. bytearray()方法返回一個新字節(jié)數(shù)組。這個數(shù)組里的元素是可變的，并且每個元素的值范圍: 0 = x 256（即0-255）。即bytearray()是可修改的二進(jìn)制字節(jié)格式。
7. callable()函數(shù)用于檢查一個對象是否可調(diào)用的。對于函數(shù)、方法、lambda函式、類以及實現(xiàn)了 __call__ 方法的類實例, 它都返回 True。（可以加括號的都可以調(diào)用）
8. chr()函數(shù)用一個范圍在range(256)內(nèi)（即0～255）的整數(shù)作參數(shù)，返回一個對應(yīng)的ASCII數(shù)值。
9. dict()函數(shù)用來將元組/列表轉(zhuǎn)換為字典格式。
10. dir()函數(shù)不帶參數(shù)時，返回當(dāng)前范圍內(nèi)的變量、方法和定義的類型列表；帶參數(shù)時，返回參數(shù)的屬性、方法列表。
擴展資料：
如何查看python3.6的內(nèi)置函數(shù)？
1、首先先打開python自帶的集成開發(fā)環(huán)境IDLE；
2、然后我們直接輸入"dir(__builtins__)",需要注意的是builtins左右的下劃線都是兩個；
3、回車之后我們就可以看到python所有的內(nèi)置函數(shù)；
4、接下來我們學(xué)習(xí)第二種查看python內(nèi)置函數(shù)的方法，我們直接在IDLE中輸入"import builtins",然后輸入"dir(builtins)"；
5、然后回車，同樣的這個方法也可以得到所有的python內(nèi)置的函數(shù)；
6、這里我們可以使用python內(nèi)置函數(shù)len（）來查看python內(nèi)置函數(shù)的個數(shù)，這里我們直接輸入"len(dir(builtins))"；
7、回車之后我們可以看到系統(tǒng)返回值153，說明我們現(xiàn)在這個版本中有153個內(nèi)置函數(shù)；
8、最后我們介紹一個比較有用的內(nèi)置函數(shù)"help"，python內(nèi)置函數(shù)有一百多個，我們當(dāng)然不能記住所有的函數(shù)，這里python提供了一個"help"函數(shù)，我們來看一個例子一起來體會一下help函數(shù)的用法，這里我們直接輸入"help(len)",然后回車，會看到系統(tǒng)給我們對于內(nèi)置函數(shù)"len"的解釋，當(dāng)然對于其他函數(shù)可能會有更加詳細(xì)的解釋以及用法提示。
在學(xué)習(xí)Python的過程中，有幾個比較重要的內(nèi)置函數(shù)：help()函數(shù)、dir()函數(shù)、input()與raw_input()函數(shù)、print()函數(shù)、type()函數(shù)。
第一、help()函數(shù)
Help()函數(shù)的參數(shù)分為兩種：如果傳一個字符串做參數(shù)的話，它會自動搜索以這個字符串命名的模塊、方法等;如果傳入的是一個對象，就會顯示這個對象的類型的幫助。比如輸入help(‘print’)，它就會尋找以‘print’為名的模塊、類等，找不到就會看到提示信息;而print在Python里是一個保留字，和pass、return同等，而非對象，所以help(print)也會報錯。
第二、dir()函數(shù)
dir()函數(shù)返回任意對象的屬性和方法列表，包含模塊對象、函數(shù)對象、字符串對象、列表對象、字典對象等。盡管查找和導(dǎo)入模塊相對容易，但是記住每個模塊包含什么卻不是這么簡單，您并不希望總是必須查看源代碼來找出答案。Python提供了一種方法，可以使用內(nèi)置的dir()函數(shù)來檢查模塊的內(nèi)容，當(dāng)你為dir()提供一個模塊名的時候，它返回模塊定義的屬性列表。dir()函數(shù)適用于所有對象的類型，包含字符串、整數(shù)、列表、元組、字典、函數(shù)、定制類、類實例和類方法。
第三、input與raw_input函數(shù)
都是用于讀取用戶輸入的，不同的是input()函數(shù)期望用戶輸入的是一個有效的表達(dá)式，而raw_input()函數(shù)是將用戶的輸入包裝成一個字符串。
第四、Print()函數(shù)
Print在Python3版本之間是作為Python語句使用的，在Python3里print是作為函數(shù)使用的。
第五、type()函數(shù)
Type()函數(shù)返回任意對象的數(shù)據(jù)類型。在types模塊中列出了可能的數(shù)據(jù)類型，這對于處理多種數(shù)據(jù)類型的函數(shù)非常有用，它通過返回類型對象來做到這一點，可以將這個類型對象與types模塊中定義類型相比較。
python系統(tǒng)提供了下面常用的函數(shù)：
1. 數(shù)學(xué)庫模塊（math）提供了很多數(shù)學(xué)運算函數(shù)；
2.復(fù)數(shù)模塊（cmath）提供了用于復(fù)數(shù)運算的函數(shù)；
3.隨機數(shù)模塊（random）提供了用來生成隨機數(shù)的函數(shù)；
4.時間（time）和日歷（calendar）模塊提供了能處理日期和時間的函數(shù)。
注意：在調(diào)用系統(tǒng)函數(shù)之前，先要使用import 語句導(dǎo)入 相應(yīng)的模塊
該語句將模塊中定義的函數(shù)代碼復(fù)制到自己的程 序中，然后就可以訪問模塊中的任何函數(shù)，其方 法是在函數(shù)名前面加上“模塊名.”。
希望能幫到你。
內(nèi)置函數(shù)就是Python給你提供的，拿來直接用的函數(shù)，比如print.，input等。
截止到python版本3.6.2 ，python一共提供了68個內(nèi)置函數(shù)，具體如下
本文將這68個內(nèi)置函數(shù)綜合整理為12大類，正在學(xué)習(xí)Python基礎(chǔ)的讀者一定不要錯過，建議收藏學(xué)習(xí)！
（1）列表和元組
（2）相關(guān)內(nèi)置函數(shù)
（3）字符串
frozenset 創(chuàng)建一個凍結(jié)的集合，凍結(jié)的集合不能進(jìn)行添加和刪除操作。
語法：sorted(Iterable, key=函數(shù)(排序規(guī)則), reverse=False)
語法：fiter(function. Iterable)
function: 用來篩選的函數(shù). 在?lter中會自動的把iterable中的元素傳遞給function. 然后根據(jù)function返回的True或者False來判斷是否保留留此項數(shù)據(jù) , Iterable: 可迭代對象
搜索公眾號頂級架構(gòu)師后臺回復(fù)“面試”，送你一份驚喜禮包。
語法 : map(function, iterable)
可以對可迭代對象中的每一個元素進(jìn)行映射. 分別去執(zhí)行 function
hash : 獲取到對象的哈希值(int, str, bool, tuple). hash算法:(1) 目的是唯一性 (2) dict 查找效率非常高, hash表.用空間換的時間 比較耗費內(nèi)存
重慶分公司
重慶分公司
