Python基础

Python基础

一、基本类型

        整数、浮点数、字符串、布尔值、空值

    1、字符串        

         常见的占位符有：

        占位符 替换内容

        %d  -- 整数

        %f  -- 浮点数

        %s  -- 字符串

        %x  -- 十六进制整数

            eg：str = 'hello %s, you age is %d' % ('Jack', 800)

二、扩展类型

    1、list类型

        1）list是一种有序的集合，可以随时添加和删除其中的元素

        2）classmates = ['Michael', 'Bob', 'Tracy']

        3）classmates[0]

              classmates[-3]

        4）要删除list末尾的元素，用pop()方法：classmates.pop()

        5）要删除指定位置的元素，用pop(i)方法，其中i是索引位置：classmates.pop(1)

        6）要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：classmates[1] = 'Sarah'

        7）list里面的元素的数据类型也可以不同，比如：L = ['Apple', 123, True]

        8）list元素也可以是另一个list，比如：s = ['python', 'java', ['asp', 'php'], 'scheme']

        9）如果一个list中一个元素也没有，就是一个空的list，它的长度为0：

    2、tuple类型

        1）tuple一旦初始化就不能修改，比如同样是列出同学的名字：classmates = ('Michael', 'Bob', 'Tracy')

        2）因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple

        3）当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：t = (1, 2)

        4）如果要定义一个空的tuple，可以写成()：t = ()

        5）要定义一个只有1个元素的tuple，如果你这么定义：t = (1,)

    3、dict类型

        1）使用键-值（key-value）存储，具有极快的查找速度

        2）

# 假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list
names = ['Michael', 'Bob', 'Tracy']
scores = [95, 75, 85]
# 用Python写一个dict如下
d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}

 

1

# 假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list

2

names = ['Michael', 'Bob', 'Tracy']

3

scores = [95, 75, 85]

4

# 用Python写一个dict如下

5

d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}

        3）除了初始化时指定外，还可以通过key放入：

d['Adam'] = 67

 

1

d['Adam'] = 67

        4）如果key不存在，dict就会报错，避免key不存在的错误，有两种办法，一是通过in判断key是否存在，二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value。

d['Thomas'] #没有值，会报错。Traceback (most recent call last):
'Thomas' in d #第一种方法，判断key是否存在
d.get('Thomas') #第二种方法，判断key是否存在
d.get('Thomas', -1) #第二种方法中的变种，自己指定不存在时返回的数值

 

1

d['Thomas'] #没有值，会报错。Traceback (most recent call last):

2

'Thomas' in d #第一种方法，判断key是否存在

3

d.get('Thomas') #第二种方法，判断key是否存在

4

d.get('Thomas', -1) #第二种方法中的变种，自己指定不存在时返回的数值

        5）删除一个key，用pop(key)方法，对应的value也会从dict中删除：

d.pop('Bob')

 

1

d.pop('Bob')

        6）和list比较，dict有以下几个特点：

            查找和插入的速度极快，不会随着key的增加而变慢；

            需要占用大量的内存，内存浪费多。

            而list相反：

            查找和插入的时间随着元素的增加而增加；

            占用空间小，浪费内存很少

        7）需要牢记的第一条就是dict的key必须是不可变对象

    4、set类型

        1）set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key

        2）要创建一个set，需要提供一个list作为输入集合

s = set([1, 2, 3])

 

1

s = set([1, 2, 3])

        3）通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

s.add(4)

 

1

s.add(4)

        4）通过remove(key)方法可以删除元素：

s.remove(4)

 

1

s.remove(4)

        5）set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

s1 = set([1, 2, 3])
s2 = set([2, 3, 4])
s1 & s2

 

1

s1 = set([1, 2, 3])

2

s2 = set([2, 3, 4])

3

s1 & s2

三、条件判断

    1、if

age = 20
# 第一种：只有if
if age >= 18:
    print('your age is', age)

# 第二种：if..else
if age >= 18:
    print('your age is', age)
else:
    print('your age is', age)

# 第三种：if..elif..else
if age >= 18:
    print('adult')
elif age >= 6:
    print('teenager')
else:
    print('kid')

# 流程图
if <条件判断1>:
    <执行1>
elif <条件判断2>:
    <执行2>
elif <条件判断3>:
    <执行3>
else:
    <执行4>

 

1

age = 20

2

# 第一种：只有if

3

if age >= 18:

4

    print('your age is', age)

5

6

# 第二种：if..else

7

if age >= 18:

8

    print('your age is', age)

9

else:

10

    print('your age is', age)

11

12

# 第三种：if..elif..else

13

if age >= 18:

14

    print('adult')

15

elif age >= 6:

16

    print('teenager')

17

else:

18

    print('kid')

19

20

# 流程图

21

if <条件判断1>:

22

    <执行1>

23

elif <条件判断2>:

24

    <执行2>

25

elif <条件判断3>:

26

    <执行3>

27

else:

28

    <执行4>

四、循环

    1、for...in循环

names = ['Michael', 'Bob', 'Tracy']
for name in names:
    print(name)

 

1

names = ['Michael', 'Bob', 'Tracy']

2

for name in names:

3

    print(name)

    2、while循环

sum = 0
n = 99
while n > 0:
    sum = sum + n
    n = n - 2
print(sum)

 

1

sum = 0

2

n = 99

3

while n > 0:

4

    sum = sum + n

5

    n = n - 2

6

print(sum)

    3、break语句

n = 1
while n <= 100:
    if n > 10: # 当n = 11时，条件满足，执行break语句
        break # break语句会结束当前循环
    print(n)
    n = n + 1
print('END')

 

1

n = 1

2

while n <= 100:

3

    if n > 10: # 当n = 11时，条件满足，执行break语句

4

        break # break语句会结束当前循环

5

    print(n)

6

    n = n + 1

7

print('END')

    4、continue语句

n = 0
while n < 10:
    n = n + 1
    if n % 2 == 0: # 如果n是偶数，执行continue语句
        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行
    print(n)

 

1

n = 0

2

while n < 10:

3

    n = n + 1

4

    if n % 2 == 0: # 如果n是偶数，执行continue语句

5

        continue # continue语句会直接继续下一轮循环，后续的print()语句不会执行

6

    print(n)

        break语句可以在循环过程中直接退出循环，而continue语句可以提前结束本轮循环，并直接开始下一轮循环。这两个语句通常都必须配合if语句使用。要特别注意，不要滥用break和continue语句。break和continue会造成代码执行逻辑分叉过多，容易出错。大多数循环并不需要用到break和continue语句，上面的两个例子，都可以通过改写循环条件或者修改循环逻辑，去掉break和continue语句。

五、函数

    1、调用函数

        1）调用abs函数

abs(100)

 

1

abs(100)

        2）传入的参数数量不对，会报TypeError的错误

        3）传入的参数类型不能被函数所接受，也会报TypeError的错误

    2、定义函数

        1）定义一个函数要使用def语句，依次写出函数名、括号、括号中的参数和冒号:，然后，在缩进块中编写函数体，函数的返回值用return语句返回

def my_abs(x):
    if x >= 0:
        return x
    else:
        return -x

 

1

def my_abs(x):

2

    if x >= 0:

3

        return x

4

    else:

5

        return -x

        2）用from 文件名 import 函数名 来导入my_abs()函数，注意abstest是文件名（不含.py扩展名）

        3）空函数

def nop():
    pass

 

1

def nop():

2

    pass

        4）数据类型检查可以用内置函数isinstance()实现

def my_abs(x):
    if not isinstance(x, (int, float)):  # 检查 x 是否为 int, float 类型
        raise TypeError('bad operand type')  # 抛出异常
    if x >= 0:
        return x
    else:
        return -x

 

1

def my_abs(x):

2

    if not isinstance(x, (int, float)):  # 检查 x 是否为 int, float 类型

3

        raise TypeError('bad operand type')  # 抛出异常

4

    if x >= 0:

5

        return x

6

    else:

7

        return -x

        5）函数可以返回多值，但其实就是一个tuple类型的数据        

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

 

1

import math

2

3

def move(x, y, step, angle=0):

4

    nx = x + step * math.cos(angle)

5

    ny = y - step * math.sin(angle)

6

    return nx, ny

    3、函数的参数

        1）位置参数

def power(x):
    return x * x

 

1

def power(x):

2

    return x * x

            对于power(x)函数，参数x就是一个位置参数

        2）默认参数

def enroll(name, gender, age=6, city='Beijing'):
    print('name:', name)
    print('gender:', gender)
    print('age:', age)
    print('city:', city)

x

 

1

def enroll(name, gender, age=6, city='Beijing'):

2

    print('name:', name)

3

    print('gender:', gender)

4

    print('age:', age)

5

    print('city:', city)

            tips：默认参数必须指向不变对象！

        3）可变参数

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

x

 

1

def calc(*numbers):

2

    sum = 0

3

    for n in numbers:

4

        sum = sum + n * n

5

    return sum

            tips：可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：

        4、关键字参数

def person(name, age, **kw):
    print('name:', name, 'age:', age, 'other:', kw)

# 可以传入任意个数的关键字参数    
>>> person('Bob', 35, city='Beijing')
name: Bob age: 35 other: {'city': 'Beijing'}
>>> person('Adam', 45, gender='M', job='Engineer')
name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}
            
# 简化的写法
extra = {'city': 'Beijing', 'job': 'Engineer'}
person('Jack', 24, **extra)

x

 

1

def person(name, age, **kw):

2

    print('name:', name, 'age:', age, 'other:', kw)

3

4

# 可以传入任意个数的关键字参数    

5

>>> person('Bob', 35, city='Beijing')

6

name: Bob age: 35 other: {'city': 'Beijing'}

7

>>> person('Adam', 45, gender='M', job='Engineer')

8

name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

9

10

# 简化的写法

11

extra = {'city': 'Beijing', 'job': 'Engineer'}

12

person('Jack', 24, **extra)

            tips：可变参数允许你传入0个或任意个参数，这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入0个或任意个含参数名的参数，这些关键字参数在函数内部自动组装为一个dict

        5、命名关键字参数

            1）限制关键字参数的名字，就可以用命名关键字参数，例如，只接收city和job作为关键字参数。这种方式定义的函数如下

# 和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。
def person(name, age, *, city, job):
    print(name, age, city, job)    

x

 

1

# 和关键字参数**kw不同，命名关键字参数需要一个特殊分隔符*，*后面的参数被视为命名关键字参数。

2

def person(name, age, *, city, job):

3

    print(name, age, city, job)    

            2）如果函数定义中已经有了一个可变参数，后面跟着的命名关键字参数就不再需要一个特殊分隔符*了

def person(name, age, *args, city, job):
    print(name, age, args, city, job)    

x

 

1

def person(name, age, *args, city, job):

2

    print(name, age, args, city, job)    

            tips：如果没有可变参数，就必须加一个*作为特殊分隔符。如果缺少*，Python解释器将无法识别位置参数和命名关键字参数

        6、参数组合

            1）在Python中定义函数，可以用必选参数、默认参数、可变参数、关键字参数和命名关键字参数，这5种参数都可以组合使用。但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数、命名关键字参数和关键字参数。

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

# 在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去
>>> f1(1, 2)
a = 1 b = 2 c = 0 args = () kw = {}
>>> f1(1, 2, c=3)
a = 1 b = 2 c = 3 args = () kw = {}
>>> f1(1, 2, 3, 'a', 'b')
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}
>>> f1(1, 2, 3, 'a', 'b', x=99)
a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}
>>> f2(1, 2, d=99, ext=None)
a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

# 最神奇的是通过一个tuple和dict，你也可以调用上述函数
>>> args = (1, 2, 3, 4)
>>> kw = {'d': 99, 'x': '#'}
>>> f1(*args, **kw)
a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}
>>> args = (1, 2, 3)
>>> kw = {'d': 88, 'x': '#'}
>>> f2(*args, **kw)
a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}
# 虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。

x

 

1

def f1(a, b, c=0, *args, **kw):

2

    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

3

4

def f2(a, b, c=0, *, d, **kw):

5

    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

6

7

# 在函数调用的时候，Python解释器自动按照参数位置和参数名把对应的参数传进去

8

>>> f1(1, 2)

9

a = 1 b = 2 c = 0 args = () kw = {}

10

>>> f1(1, 2, c=3)

11

a = 1 b = 2 c = 3 args = () kw = {}

12

>>> f1(1, 2, 3, 'a', 'b')

13

a = 1 b = 2 c = 3 args = ('a', 'b') kw = {}

14

>>> f1(1, 2, 3, 'a', 'b', x=99)

15

a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99}

16

>>> f2(1, 2, d=99, ext=None)

17

a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

18

19

# 最神奇的是通过一个tuple和dict，你也可以调用上述函数

20

>>> args = (1, 2, 3, 4)

21

>>> kw = {'d': 99, 'x': '#'}

22

>>> f1(*args, **kw)

23

a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'}

24

>>> args = (1, 2, 3)

25

>>> kw = {'d': 88, 'x': '#'}

26

>>> f2(*args, **kw)

27

a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

28

# 虽然可以组合多达5种参数，但不要同时使用太多的组合，否则函数接口的可理解性很差。

    4、递归函数

        1）函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数

        2）我们来计算阶乘n! = 1 x 2 x 3 x ... x n，用函数fact(n)表示，可以看出

# fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n
# 所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。
# 于是，fact(n)用递归的方式写出来就是：
def fact(n):
    if n==1:
        return 1
    return n * fact(n - 1)

x

 

1

# fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n

2

# 所以，fact(n)可以表示为n x fact(n-1)，只有n=1时需要特殊处理。

3

# 于是，fact(n)用递归的方式写出来就是：

4

def fact(n):

5

    if n==1:

6

        return 1

7

    return n * fact(n - 1)

六、高级特性