字符串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