Python3 与 C# 基础语法对比（Function专栏）

# 空函数定义
def method():
    pass #至关于占位符，ifelse等等里面都是能够出现的

method()

# 定义一个无参函数
def get_name():
    print("我叫张三")

# 调用一个无参函数
get_name()

# 定义一个含参数的函数（name和age都是形参）
def show_infos(name,age):
    """打印name和age"""#函数文档说明
    print("我叫",name,"个人年龄是",age)#这种输出方式会自动以空格链接字符串

# 调用一个含参数的函数
show_infos("李四",22)#实参

# 定义一个含默认参数(缺省参数)的函数（默认参数必须指向不变对象）
# 好比你设置一个list，改变了内容，则下次调用时，默认参数(缺省参数)的内容就变了，再也不是函数定义时的值了
def default_param(name,age=23):
    """age默认为23"""
    print("我叫",name,"个人年龄是",age)#这种输出方式会自动以空格链接字符串

# 调用一个默认参数(缺省参数)的函数
default_param("张三")

# 定义有返回值的函数
def div_have_return(a,b):
    """计算a+b，返回计算结果"""#函数文档说明
    return a+b

# 调用有返回值的函数
result=div_have_return(1,2)
print("计算结果为",result)

# 定义含有多个返回值的函数（利用了元组）
def div_have_returns(a,b):
    """计算a+b的和，计算a-b，并返回两个结果"""
    return (a+b),(a-b)

# 调用含有多个返回值的函数
sum,dvalue=div_have_returns(1,2)
print("sum:",sum,"D-value:",dvalue)

# 测试一下～返回多个值实际上是利用了元组
# 多返回值只是一种假象，Python函数返回的仍然是单一值～元组
test=div_have_returns(1,2)
print(test)

# 定义函数时，须要肯定函数名和参数个数
# 若是有必要，能够先对参数的数据类型作检查
# 函数体内部能够用return随时返回函数结果
# 函数执行完毕也没有return语句时，自动return None
# 函数能够同时返回多个值，但其实就是一个tuple

# 扩展：使用list实现
# 定义含有多个返回值的函数（利用了元组）
def div_have_returns(a,b):
    """计算a+b的和，计算a-b，并返回两个结果"""
    return [a+b,a-b]

# 调用含有多个返回值的函数
div_have_returns(1,2)

######## 经过元组、列表实现 ########
def default_some_params(nums):
    """借助Tuple和list"""
    sum=0
    for item in nums:
        sum+=item
    return sum

# 元组传入
default_some_params((1,2,3,4,5))

# 列表传入
default_some_params(list(range(1,6)))

######## 定义一个可变参数的函数(名字通常都是*args) ########
# 定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。
# 在函数内部，接收到的参数是一个tuple。调用该函数时，能够传入任意个参数（包括0个参数）
def default_params(*args):
    """定义一个可变参数,用来求全部参数的总和"""
    sum=0
    for item in args:
        sum+=item
    return sum

# 调用一个可变参数的函数
default_params(1,2,3,4,5)

# 传一个list或者Tuple（参数前面加*）
# 传一个元组
test_tuple=(1,2,3,4,5)
default_params(*test_tuple)

# range(1,6) ==> [1,6) ==> 1,2,3,4,5
test_list=list(range(1,6))
default_params(*test_list)

######## 调用含关键字参数的函数 ########
# 可变参数容许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple
# 关键字参数容许你传入0个或任意个含key-value的参数，自动组装为一个dict
def default_kv_params(name,age=23,**kv):
    """输出输出用户传参"""
    print("我叫",name,"个人年龄是",age,"dict:",kv)

# 调用含关键字参数的函数
default_kv_params("dnt",web="www.baidu.com",qq=110)

#### 同时定义可变参数+关键字参数 ####
def default_god_params(name,age=23,*args,**kv):
    """同时有可变参数+关键字参数的使用方法"""
    print("我叫",name,"个人年龄是",age,"list:",args,"dict:",kv)

# 调用可变参数+关键字参数
# 有名字给kv,没名字给args
default_god_params("dnt",24,1,2,3,4,5,web="www.baidu.com",qq=110)

#只调用可变参数
default_god_params("dnt",24,1,2,3,4,5)

# 只调用关键字参数
default_god_params("dnt",web="www.baidu.com",qq=110)

#### 传元组和字典 ####
test_tuple=(1,2,3,4,5)
test_dict={"web":"www.baidu.com","qq":110}

default_god_params(*test_tuple,**test_dict)

# 函数递归调用其实就是本身调用本身，关键点只要考虑何时跳出便可(没有跳出就是死循环)
# 阶乘案例 n!
def factorial(n):
    if n==1:
        return n #跳出
    elif n>1:
        return n*factorial(n-1) #规律公式

print(factorial(4))
print(factorial(-4))

# 利用切片操做，实现一个trim()函数，去除字符串首尾的空格
# 跳出点==> 第一个字符和最后一个字符不是空格
def my_trim(input_str):
    if input_str[0] != " " and input_str[-1] != " ":
        return input_str
    elif input_str[0]==" ":
        return my_trim(input_str[1:])#从第二个到最后一个字符
    elif input_str[-1]==" ":
        return my_trim(input_str[:-1])#从第一个到倒数第二个(end_index取不到)

print(my_trim("我去  "))
print(my_trim("  我去"))
print(my_trim("  我去  "))

# Python对匿名函数的支持有限，只有一些简单的状况下可使用匿名函数
# lambda 参数: 表达式
# 来个简单求和案例:
sum=lambda a,b: a+b

sum(1,2) #调用一下看看(有点js的感受,函数能够直接赋值给变量,而后直接用)

# 来个实际案例,还记得list的排序吗?
# 此次按照指定key排序(有点 SQL 里面 order by 的感受)
data_list=[
    {"name":"a张三","age":21},
    {"name":"b李四","age":23},
    {"name":"a王五","age":22}]

# 按照age排序
data_list.sort(key=lambda x:x["age"])
print(data_list)

# 按照name排序
data_list.sort(key=lambda x:x["name"])
print(data_list)

# 能够看看帮助文档
help(data_list.sort)

# 当函数的参数传递(有时候须要传一个匿名方法去函数中处理某些事情)
def sum(a,b,func):
   return func(a,b)

sum(1,2,lambda x,y: x+y)

# 有人可能会说，这个就太简单了，没啥好说的，(⊙o⊙)… Python还真须要说说
a=100
b=[1,2]

def set_num(num):
    num+=num

set_num(a)
set_num(b)

# 发现全局变量a木有被修改，而b修改了
print(a)
print(b)

# 仍是来个简单案例说明下吧～
a=100

def set_num(num):
    a=200

set_num(a)
print(a)

# a=200，python解释器就认为你定义了一个和a这个全局变量名字相同的局部变量，那怎么用呢？global来声明一下便可
a=100

def set_num(num):
    global a
    a=200

set_num(a)
print(a)

a="mmd"

a[0]

# 无法修改
a[0]='d'

a=['m','m','d']
a[0]

a[0]='n'
a

i=1
id(i)

# 地址改变了
i+=1
id(i)

# 地址又变了
i=i+1
id(i)

j=1
id(j) # 有没有发现，跟一开始i的内存地址同样了

# 更直观的来几个案例
a=1
b=1
c=1

# 不只仅都同样，还和全部等于1的变量地址都相同
# 这下不怀疑了吧
print(id(a))
print(id(b))
print(id(c))

f1=1.2
id(f1)

# 地址变了，说明float也是不可变类型
f1+=1.0
id(f1)

f2=1.2
f3=1.2
print(id(f2))
print(id(f3))

list1=[12,11,1]
id(list1)

# 改完仍是本身原来的地址～说明是可变类型
list1.append(0)
id(list1)

# 当存在多个值相同的不可变类型变量时，并非指向同一个地址
list2=[12,11,1]
list3=[12,11,1]
print(id(list2))
print(id(list3))

print(id(list2))
print(id(list3))
list3=list2
print(id(list3)) # 如今list3的地址和list2地址同样了

# 注意这种状况，若是对其中一个list修改，那么另外一个也就跟着被修改了
# 任意一个List进行修改，都会影响另一个List的值
list2.append(0)
print(list2)
print(list3)
print(id(list2))
print(id(list3))

# 以前不少资料说py3匿名函数里不能调用print函数,本身测试下
# 定义一个无参匿名函数
printf=lambda:print("I Love You")

printf()

# 可变类型与不可变类型的变量分别做为函数参数的区别
def default_some_params(nums):
    nums+=nums

test_num=1
default_some_params(test_num)
test_num

test_list=list(range(1,6))
default_some_params(test_list)
test_list

# 函数名能不能重复的问题（能不能重载：具备不一样的参数的类型或参数的个数）
def test():
    pass

def test(a,b):
    return a+b

test(1,2)

test() #前一个直接被后一个覆盖掉了

# 交换两数～元组的方式
a=1
b=2
a,b=b,a # 写全：(a,b)=(b,a)
print(a)
print(b)

# 2.eval（和js里面的eval差很少）：
input_str=input("请输入：")
print(input_str)
eval(input_str)