python函数

# 定义函数

# 如果不主动调用函数，函数是不会执行的
def say_hello():
    print 'hello1'
    print 'hello2'
    print 'hello3'

# 函数的调用
say_hello()

hello1
hello2
hello3

def sum_2_sum():
    """对两个数字的求和"""
    num1 = 20
    num2 = 20
    result = num1 + num2
    print '%d + %d = %d' %(num1,num2,result)

sum_2_sum()

20 + 20 = 40

 

函数参数的使用
在函数名后面的小括号内填写 参数
多个参数之间使用 , 分隔

# 定义函数时的变量，叫形参 形参可以任意起名字
def sum_2_sum(num1, num2):
    result = num1 + num2
    print '%d + %d = %d' % (num1, num2, result)

# 在调用函数的时候
# 在调用函数时传递得参数称为实参(真实的数据信息)
sum_2_sum(5, 20)

5 + 20 = 25

局部变量：在函数内部定义的普通变量，只在函数内部作用，函数执行结束
变量会自动删除
全局变量

a = 1

print 'outside:', id(a)


def fun():
    global a  # 声明a为全局变量
    a = 5
    print 'inside:', id(a)


fun()
print a
print id(a)

outside: 17730664
inside: 17730568
5
17730568

参数:形参 实参
形参：位置参数 默认参数 可变参数 关键字参数
# 位置参数：形参和实参个数必须保持一致

def getInfo(name,age):
    print name, age


getInfo(age=12, name='westos')

westos 12
# 默认参数:形参和实参的个数可以不一致

def mypow(x, y=2):
    print x ** y


mypow(4)
# 默认形参可以改变
mypow(4, 3)

16
64

# 可变参数

def mysum(*agrs):
    """
    *args:是可变参数
     args：是元组类型数据
     args:名字可变(因为是形参 名字可变)
    :param agrs:
    :return:
    """
    print agrs
    sum = 0
    for item in agrs:
        sum += item
    print sum


mysum(1, 2, 3, 4, 5)

(1, 2, 3, 4, 5)
15

def mysum(*agrs):
    print agrs
    sum = 0
    for item in agrs:
        sum += item
    print sum


# 对list tuple set 解包时，只需要在变量前加 *
nums = [1, 2, 3, 4, 66, 78]
nums1 = (1, 2, 3, 4, 5)
nums2 = {1, 2, 3}
# *nums:解包
mysum(*nums2)

(1, 2, 3)
6

# 4.关键字参数

def getStuInfo(name, age, **kwargs):
    """
    **kwargs：是一个字典；可以传递任意多的key-value对
    :param name:
    :param age:
    :param kwargs:
    :return:
    """
    print name, age
    print kwargs


getStuInfo('westos', 18, hobbies=['code', 'running'], gender='female')

westos 18
{'gender': 'female', 'hobbies': ['code', 'running']}

返回值：函数运算的结果，还需要进一步操作时，给一个返回值
return用来返回函数执行结果的,如果没有返回值，默认为None
python可以间接返回多个值(返回了一个元组)
一旦遇到return,函数执行结束，后面的代码不会执行

def mypow(x, y=2):
    return x ** y, x + y
    print 'hello'


# 对元组进行解包
a, b = mypow(3)
print a, b

9 5

列表生成式

1.

s = '51 5000 10000'
li = []
for item in s.split():
    li.append(int(item))
k, a, b = li
print k, a, b

51 5000 10000

s = '51 5000 10000'
k, a, b = [int(item) for item in s.split()]
print k,a,b

51 5000 10000

# 2.生成一个列表，列表元素分别为[1**2,2**2,3**2,4**2...n**2]

li = []
for i in range(1, 8):
    li.append(i ** 2)
print li

[1, 4, 9, 16, 25, 36, 49]

print [i ** 2 for i in range(1, 8)]

[1, 4, 9, 16, 25, 36, 49]

print [i ** 2 for i in range(1, 8) if i % 2 == 0]

[4, 16, 36]

 

# 1.找出1~10之间的所有偶数，并且返回一个列表(包含以这个偶数为半径的圆的面积)

li = []
for r in range(2, 11, 2):  # [2,4,6,8,10]
    square = math.pi * r * r
    li.append(square)
print li

[12.566370614359172, 50.26548245743669, 113.09733552923255, 201.06192982974676, 314.1592653589793]

print [math.pi * r * r for r in range(2, 11, 2)]

[12.566370614359172, 50.26548245743669, 113.09733552923255, 201.06192982974676, 314.1592653589793]

# 2.找出1～10之间的所有奇数，并且返回一个列表(所有的奇数转换为字符串)

print [str(r) for r in range(1,11,2)]

['1', '3', '5', '7', '9']

#3.找出1～num之间的所有质数

def isPrime(num):
    for i in range(2,num):
        if num % i == 0:
            return False
    else:
        return True

print [i for i in range(2,101) if isPrime(i)]

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

字典生成式

# 1.假设有20个学生，学分在60～100之间，筛选出成绩在90分以上的学生

import random

stuInfo = {}
for i in range(20):
    name = 'westos' + str(i)
    score = random.randint(60,100)
    stuInfo[name] = score
#     stuInfo['westos'+str(i)] = random.randint(60,100)
hightscore = {}
for name,score in stuInfo.items():
    if score > 90:
        hightscore[name] = score
print hightscore

{'westos13': 98}

import random
stuInfo = {'westos' + str(i): random.randint(60, 100) for i in range(20)}
print {name: score for name, score in stuInfo.items() if score > 90}

{'westos11': 97, 'westos14': 95, 'westos15': 95, 'westos16': 95, 'westos5': 97, 'westos8': 95}

# 2.将字典中的key值和value值调换

d = {'a': 'apple', 'b': 'bob', 'c': 'cat'}
print {v: k for k, v in d.items()}

{'bob': 'b', 'apple': 'a', 'cat': 'c'}

d = {'a': 'apple', 'b': 'bob', 'c': 'cat'}
print {k: k.upper() for k, v in d.items()}

{'a': 'A', 'c': 'C', 'b': 'B'}

# 3.大小写合并，key值最终全部为小写

d1 = {'A': 10, 'b': 3, 'a': 5, 'B': 8, 'd': 1}
print {k.lower(): d1.get(k.upper(), 0) + d1.get(k.lower(), 0) for k, v in d1.items()}

{'a': 15, 'b': 11, 'd': 1}