python3基础语法

1.条件控制

x = 1
if x < 1:
    print("x小于1")
elif x > 1:
    print("x大于1")
else:
    print("x等于1")

注意点：

• 每个条件后面要使用冒号
• 使用缩进来划分语句块
• python中没有switch-case语句
• if可以嵌套

2.while循环语句

2.1.while循环

• python中没有do-while循环

n = 100
sum = 0
while n > 0:
    sum += n
    n -= 1
print(sum)   # 5050

2.2.无限循环

• 可以使用ctrl+c来退出当前的无限循环

x = 1
while x == 1:
    num = int(input("输入一个数字："))
    print("您输入的数字是：", num)
print("end")

2.3.while循环只用else语句

x = 1
while x > 1:
    print("x > 1")
else:
    print("x = 1")

3.for循环语句

list = ["c", "java", "python", "php"]
for x in list:
    print(x, end=" ")

3.1.for循环中的break语句

for x in list:
    if x == "python":
        print("python")
        break
    else:
        print(1)
else:
    print("循环结束")
print("退出")

3.2.range（）函数

• 常用于遍历数字序列

for i in range(10):
    print(i, end=" ")

• 遍历指定区间

for i in range(5, 10):
    print(i, end=" ")

• 指定步长

for i in range(5, 10, 2):
    print(i, end=" ")

• 也可以结合range（）和len（）函数以遍历一个序列的索引

a = (1, 2, 3, 4, 5)
for x in range(len(a)):
    print(a[x], end=" ")

• 使用range（）函数来创建一个列表列表

4.pass语句

• 空语句，为了保证程序结构的完整性
• pass不做任何事情，一般只用做占位语句

for x in "fireFox":
    if x == 'o':
        pass
        print("执行pass语句")
    print("当前字母：", x)
print("结束循环")

5.迭代器

• 是一个可以记住遍历的位置的对象
• 迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束，迭代器只能往前不会后退
• 两个基本方法：iter（）和next（）
• 字符串，列表，或元组对象都可用于创建迭代器

list = [1, 2, 3, 4]
it = iter(list)   # 创建迭代器对象
print(next(it))   # 输出迭代器的下一个元素 1
print(next(it))   # 输出迭代器的下一个元素 2
print(next(it))   # 输出迭代器的下一个元素 3
print(next(it))   # 输出迭代器的下一个元素 4

• 可以在for循环中使用迭代器

list = [1, 2, 3, 4]
it = iter(list)
for x in it:
    print(x, end=" ")

6.函数

6.1.定义一个函数

• 函数代码块以def关键字开头，后接函数标识符名称和圆括号（）
• 任何传入参数和自变量都必须放在元括号中间，圆括号之间可以用于定义参数
• 函数的第一行语句可以选择性的使用文档字符串用于存放函数说明
• 函数内容以冒号起始，并且缩进
• return 【表达式】结束函数，选择性的返回一个值给调用方，不带表达式的return相当于返回None
• 默认情况下，参数值和参数名称是按函数声明中定义的顺序匹配起来的

我的第一个函数：

def hello():
    print("hello world!")
hello()

也可以带上参数

def hello2(x, y):
    if x > y:
        return x
    elif x < y:
        return y
    else:
        return "一样大"
x = 1
y = 2
print(max(x, y))

6.2.函数调用

定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构，这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从python命令提示符执行

def printme(str):
    print(str)
printme("lyh")   # lyh
printme("liyuhuan")   # liyuhuan

6.3.参数传递

• 在python中，类型属于对象，变量是没有类型的
• python中一切都是对象，严格意义上我们不能说值传递还是引用传递，我们应该说传不可变对象和传可变对象

a = [1, 2, 3]
a = "liyuhuan"

以上代码中，[1,2,3]是List类型，"liyuhuan"是string类型，而棉量a是没有类型的，它仅仅是一个对象的引用（一个指针），可以是指向List类型对象，也可以是指向String类型对象
可变和不可变对象：
（1）不可变：

• string，tuples，numbers
• 举个例子：a=1 a=10在这段代码中，变量a先赋值1，再赋值10，事实上，不是改变了a的值，而是新生成了一个int值对象10，让a指向它，相当于是改变了a指向的对象

（2）可变：

• list，dict
• 举个例子，list=[1, 2, 3, 4] list[1] = 2.2是将list的第二个元素的值修改了，本身list变量是没有变化的，只是其内部的一部分值被修改了

python函数的参数传递：

• 不可变类型：值传递，传递的只是对象的值，并没有影响对象本身，如果在函数内部修改对象的值，则是新生成一个对象
  举个例子：

def fun(a):
    a = 1
    print("函数内：a=", a)
    print("函数内a的内存地址为:", id(a))
a = 4
fun(a)
print("函数外：a=", a)
print("函数外a的内存地址为:", id(a))

运行结果：

• 可变类型：引用传递，是真正的将对象传过去，修改变量值后外部的变量也会受影响
  举个例子：

list = [1, 2, 3, 4]
def fun2(list):
    list[0] = 1.1
    print("函数内：list=", list)
    print("函数内list的内存地址为:", id(list))
fun2(list)
print("函数外，list=", list)
print("函数内list的内存地址为:", id(list))

运行结果：

6.4.参数

• 必须参数
• 关键字参数
• 默认参数
• 不定长参数

6.4.1.必须参数

• 需要以正确的顺序传入参数，调用时的数量必须和声明时的一样，如下实例：

def printme(str):
    print(str)
printme("lyh")   # lyh
# printme()   # 会报错
printme("liyuhuan")   # liyuhuan

6.4.2.关键字参数

• 函数调用使用关键字参数来确定传入的参数值
• 使用关键字参数允许函数调用时参数的顺序与声明时不一致，python解释器能够用参数名匹配参数值

def print2( name, sex):
    print("name:", name)
    print("sex:", sex)
    return
print2(sex="女", name='lyh')

6.4.3.默认参数

• 调用函数时，如果没有传递参数，则会使用默认参数

def print3( name, sex='女'):
    print("name:", name,end=" ")
    print("sex:", sex)
    return
print3( sex="男", name='lyh')
print3(name='lyh')

6.4.4.不定长参数

• 你可能需要一个函数能处理比当初声明时更多的参数，叫不定长参数
• *表示以元组的形式导入，存放所有未命名的变量参数
• 如果单独出现*号，星号后的参数必须用关键字传入
• **表示以字典的形式导入，存放所有未命名的变量参数
• 如果在函数调用时，没有指定参数，他就是一个空元组，我们也可以不向函数传递未命名的变量

def print4( num, *vartuple ):
    print(num, end=",")
    print(vartuple)
print4( 1, 2, 3)

def print5( num, *vartuple ):
    print(num)
    for x in vartuple:
        print(x)
    return
print5(1)
print("=======")
print5(1, 2, 3)

def print6( **var_dic):
    print(var_dic)
    return
print6(a=1, b=2)

def print7(a, b, *, c):
    return a+b+c
print(print7(1, 2, c=3))   # 6

7.匿名函数、return语句

7.1匿名函数

python使用lambda来创建匿名函数

• lambda只是一个表达式。函数体比def简单很多
• lambda的主体是一个表达式，而不是一个代码块，仅仅能在lambda表达式中封装有限的逻辑进去
• lambda函数拥有自己的命名空间，且不能访问自己参数列表之外或全局命名空间里的参数

sum = lambda num1, num2, num3: num1 + num2 + num3
print("sum=", sum(1, 2, 3))   # sum= 6
print("sum=", sum(2, 3, 4))   # sum= 9

7.2.return语句

• 用于退出函数，选择性的向调用方返回一个表达式，不带参数值的return语句返回None

def sum(num1, num2):
    count = num1 + num2
    print("函数内count=", count)
    return count
count = sum(1, 2)
print("函数外count=", count)