亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

字符串format由兩個部分組成，字符串模板和模板數據內容組成，通過大括號{}，就可以把模板數據內容嵌到字符串模板對應的位置。

def greet(n=123):

? ? if n == 123:

? ? ? ? print("Hello,world")

? ? else:

? ? ? ? print("hello")

? ? ? ??

# x = 11

# y = greet(x)

# print(y)

greet(1)

? ??

# Enter a code

def func(aa):

? ? i = 0

? ? sum = 0

? ? pro = 1

? ? if isinstance(aa, list):

? ? ? ? for i in aa:

? ? ? ? ? ? sum += i

? ? ? ? return sum

? ? ? ??

? ? elif isinstance(aa, tuple):

? ? ? ? for i in aa:

? ? ? ? ? ? pro= pro * i

? ? ? ? return pro

? ? ? ??

list1 = [1,2,3,4]

k = func(list1)

tuple1 = (1,2,3,4)

q = func(tuple1)

print(k, q)

這個時候，我們發現，元組T中的第三個元素已經成功被改變了，這就有悖前面的定義，元組是不可改變的。那么這到底是為什么呢？

這是因為雖然tuple中的list元素改變了，但是tuple本身指向的list仍然是同一個list，list本身并沒有改變，改變的只是list里面的一個元素，這是tuple所約束不到的范圍。

而對于多個元素的tuple，則加和不加這個逗號，效果是一樣的。

>>>?T?=?(1,?2,?3,)
>>>?print(T)?#?==>?(1,?2,?3)

可以看到，改變優先級我們是通過()來實現的，這和元組的定義有沖突，這就解釋了前面只有一個元素的元組，為什么打印出來卻得到一個數字的結果了。
因為()既可以表示tuple，又可以作為括號表示運算時的優先級，結果(1)被Python解釋器計算出結果 1，導致我們得到的不是tuple，而是整數 1。
因此，要定義只有一個元素的tuple，需要在元素后面添加一個逗號 , 。

T?=?(1,?)
print(T)?#?==>?(1,?)

Python函數提供可變關鍵字參數，對于可變關鍵字參數，可以通過關鍵字的名字key找到對應的參數值。

Python會把可變關鍵字參數當作dict去處理；對于可變關鍵字參數，一般使用**kwargs來表示。

def info(**kwargs):
? ?print('name: {}, gender: {}, age: {}'.format(kwargs.get('name'), kwargs.get('gender'), kwargs.get('age')))

info(name = 'Alice', gender = 'girl', age = 16)

#——>name: Alice, gender: girl, age: 16

對于一個擁有必需參數，默認參數，可變參數，可變關鍵字參數的函數，定義順序是這樣的：

def func(param1, param2, param3 = None, *args, **kwargs):
? ?print(param1)? ——必須參數
? ?print(param2)? ——必須參數
? ?print(param3)? ——默認參數
? ?print(args)? ? ?——可變參數
? ?print(kwargs)? ?——可變關鍵字參數

func(100, 200, 300, 400, 500, name = 'Alice', score = 100)
# ==> 100? #必須參數
# ==> 200? #必須參數
# ==> 300? #默認參數
# ==> (400, 500)? #可變參數
# ==> {'name': 'Alice', 'score': 100}? #可變關鍵字參數

可變參數即任意個參數的意思，可變參數通常使用*args來表示。

def func(*args):
? ?print('args length = {}, args = {}'.format(len(args), args))

func('a') # ==> args length = 1, args = ('a',)
func('a', 'b') # ==> args length = 2, args = ('a', 'b')
func('a', 'b', 'c') # ==> args length = 3, args = ('a', 'b', 'c')

注意，在使用上，Python會把可變參數定義為一個tuple，所以在函數內部，把可變參數當作tuple來使用就可以了，比如可以通過位置下標取出對應的元素等。

def average(*args):
? ?sum = 0
? ?for item in args:
? ? ? ?sum += item
? ?avg = sum / len(args)
? ?return avg

average(1, 2) # ==> 1.5
average(1, 2, 2, 3, 4) # ==> 2.4

name_set.add('Gina')
print(name_set) # ==> set(['Gina', 'Alice', 'Candy', 'David', 'Ellena', 'Bob'])

可以看到，'Gina'已經添加到name_set里面去了。對于set，如果添加一個已經存在的元素，不會報錯，也不會改變什么。

set提供了update()方法，可以一次性給set添加多個元素。
比如，新來了一批同學，名字分別是['Hally',? 'Isen',? 'Jenny',? 'Karl']，則可以使用update()方法，批量往set中添加。

names = ['Alice', 'Bob', 'Candy', 'David', 'Ellena']
new_names = ['Hally', 'Isen', 'Jenny', 'Karl']
name_set = set(names)
name_set.update(new_names) #==> set(['Jenny', 'Ellena', 'Alice', 'Candy', 'David', 'Hally', 'Bob', 'Isen', 'Karl'])
print(name_set)

定義函數的時候，還可以有默認參數，默認參數的意思是當這個參數沒有傳遞的時候，參數就使用定義時的默認值。

例如Python自帶的 int() 函數，其實就有兩個參數，我們既可以傳一個參數，又可以傳兩個參數：

int('123') # ==> 123
int('123', 8) # ==> 83

int()函數的第二個參數是轉換進制base，如果不傳，默認是十進制 (base=10)，如果傳了，就用傳入的參數。

注意的是，由于函數的參數按從左到右的順序匹配，所以默認參數只能定義在必需參數的后面，否則將會出現錯誤。

def power(x, n=2):
? ?s = 1
? ?while n > 0:
? ? ? ?n = n - 1
? ? ? ?s = s * x
? ?return s

index()方法

index()方法可以返回指定元素的下標，當一個元素多次重復出現時，則返回第一次出現的下標位置。

T?=?(1,?1,?2,?2,?3,?3,?1,?3,?5,?7,?9)
T.index(9)?#?==>?10
T.index(5)?#?==>?8
T.index(1)?#?==>?0?#?多次出現，返回第一次出現的位置

注意，index()方法和count()方法不一樣，當指定的元素不存在時，使用index()方法Python會報錯。

T?=?(1,?1,?2,?2,?3,?3,?1,?3,?5,?7,?9)
T.index(100)
#?報錯
Traceback?(most?recent?call?last):
??File?"<stdin>",?line?1,?in?<module>
ValueError:?tuple.index(x):?x?not?in?tuple