Python基础知识点

一、python基础

1.缩进

python使用缩进块来组织代码块，使用4个空格的缩进

 代码形式：

a=100
if a>=0:
    print(a)
else:
    print(-a)

2.注释：

单行注释：#  多行注释：’’’ ‘’’ 或””” “”” 

3.输入input()

可以让用户输入字符串，并存放到变量里，返回数据类型是str

name=input()
print(name)

4.输出print()

• 括号中加字符串，可以向屏幕中输出指定文字，字符串使用单双引号均可（当字符中存在单引号时，要使用双引号包裹）

eg:输出‘hello，python’

print('hello,python')

• print函数可以接受多个字符串，用逗号隔开，就可以连成一串输出

print会以此打印每个字符串，遇到逗号会输出一个空格

print('hello,','python')

• print可以打印整数或计算结果

5.数据类型和变量

数据类型

在python中能够直接处理的数据类型

• 整数（①可以处理任意大小的整数包括负整数②十六进制用0x和0-9，a-f表示③对于很大的数，很难数清0的个数，允许在数字之间用_分隔）
• 浮点数（可以用数学写法如3.14，对于很大或很小的浮点数必须用科学计数法，把10用e代替）Python的浮点数也没有大小限制，但是超出一定范围就直接表示为inf（无限大）

注：整数和浮点数在计算机内部的存储方式是不同的，整数运算永远是精确的，而浮点数可能会有四舍五入的误差

• 字符串

字符串是以单引号'或双引号"括起来的任意文本

如果字符串内部既包含'又包含"，可以用转义字符\来标识，\n表示换行，\t表示制表符，\\表示的字符是\

允许用r''表示''内部的字符串默认不转义，用'''...'''的格式表示多行内容

• 布尔值

布尔值和布尔代数的表示完全一致，一个布尔值只有True、False两种值，可以直接用True、False表示布尔值（注意大小写）

布尔值可以用and、or和not运算

and运算是与运算，只有所有都为True，and运算结果才是True

or运算是或运算，只要其中有一个为True，or运算结果就是True

not运算是非运算，它是一个单目运算符，把True变成False，False变成True

• 空值

空值是Python里一个特殊的值，用None表示。None不能理解为0，因为0是有意义的，而None是一个特殊的空值

变量

变量名必须是大小写英文、数字和_的组合，且不能用数字开头

**解释整数运算永远是精确的

在Python中，有两种除法，一种除法是/：

>>> 10 / 3
3.3333333333333335

/除法计算结果是浮点数，即使是两个整数恰好整除，结果也是浮点数：

>>> 9 / 3
3.0

还有一种除法是//，两个整数的除法仍然是整数：

>>> 10 // 3
3

余数运算，可以得到两个整数相除的余数：

>>> 10 % 3
1

6.字符串和编码

对于单个字符的编码，Python提供了ord()函数获取字符的整数表示，chr()函数把编码转换为对应的字符

>>> ord('A')
65
>>> ord('中')
20013
>>> chr(66)
'B'
>>> chr(25991)
'文'

 Python的字符串类型是str，如果要在网络上传输，或者保存到磁盘上，就需要把str变为以字节为单位的bytes。

Python对bytes类型的数据用带b前缀的单引号或双引号表示：

x = b'ABC'

要注意区分'ABC'和b'ABC'，前者是str，后者虽然内容显示得和前者一样，但bytes的每个字符都只占用一个字节。

len()函数计算的是str的字符数，换成bytes，len()函数就计算字节数

常见的占位符有：

占位符	替换内容
%d	整数
%f	浮点数
%s	字符串
%x	十六进制整数

format()

另一种格式化字符串的方法是使用字符串的format()方法

f-string

最后一种格式化字符串的方法是使用以f开头的字符串，称之为f-string，它和普通字符串不同之处在于，字符串如果包含{xxx}，就会以对应的变量替换：

>>> r = 2.5
>>> s = 3.14 * r ** 2
>>> print(f'The area of a circle with radius {r} is {s:.2f}')
The area of a circle with radius 2.5 is 19.62

{2}被变量r的值替换，{s:.2f}被变量s的值替换，并且:后面的.2f表示保留两位小数

7.使用list和tuple

数据类型列表：list  有序的集合，可以随时添加和删除元素

len()函数可以获得list元素个数

classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']

>>> len(classmates)
3

用索引来访问list中每一个位置的元素，索引从0开始

>>> classmates[0]
'Michael'
>>> classmates[1]
'Bob'
>>> classmates[2]
'Tracy'
>>> classmates[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

当索引超出了范围时，Python会报一个IndexError错误，最后一个元素的索引是len(classmates) - 1。

如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：

>>> classmates[-1]
'Tracy'

也可以获取倒数第2个、倒数第3个

list是一个可变的有序表，可以往list中追加元素到末尾：

>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

也可以把元素插入到指定的位置，比如索引号为1的位置：

>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

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

>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

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

>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']

list里面的元素的数据类型也可以不同，比如：

>>> L = ['Apple', 123, True]

list元素也可以是另一个list

>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

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

>>> L = []
>>> len(L)
0

tuple

有序列表叫元组：tuple。tuple一旦初始化就不能修改

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

>>> t = ()
>>> t
()

只有1个元素的tuple定义时必须加一个逗号,

>>> t = (1,)
>>> t
(1,)

8.条件判断

if 判断条件: 

        else:

更细致的判断 

if<判断条件1>：

        <执行1>

elif<判断条件2>：

        <执行2>

else:

        <执行3>

if判断条件还可以简写，比如写：

if x:
    print('True')

只要x是非零数值、非空字符串、非空list等，就判断为True，否则为False。

9.模式匹配

如果针对某个变量匹配若干种情况，可以使用match语句=>依次用case匹配，在最后（仅能在最后）加一个case_表示任意值，case匹配多个值时用|分隔

用if语句编写：

score = 'B'
if score == 'A':
    print('score is A.')
elif score == 'B':
    print('score is B.')
elif score == 'C':
    print('score is C.')
else:
    print('invalid score.')

改为match语句：

score = 'B'
match score:
    case 'A':
        print('score is A.')
    case 'B':
        print('score is B.')
    case 'C':
        print('score is C.')
    case _: # _表示匹配到其他任何情况
        print('score is ???.')

 10.循环

Ⅰ、for…in循环：一次把list或tuple中的每个元素迭代出来

for x in …将每个元素带入变量x

**range()函数=>生成一个整数序列

eg:range(5)生成的序列从0开始小于5的整数

Ⅱ、while循环

while 条件：

break语句提前结束循环

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

continue

在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环。

n = 0
while n < 10:
    n = n + 1
    print(n)

上面的程序可以打印出1～10

如果只打印奇数，可以用continue语句跳过某些循环：

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

11.使用dict和set

dict

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

用dict实现，只需要一个“名字”-“成绩”的对照表，直接根据名字查成绩

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

print(d['Michael'])

 把数据放入dict的方法，除了初始化时指定以外，还可以通过key放入

一个key只能对应一个value，所以多次对一个key放入value后面的值会把前面的冲掉

判断key是否存在

①通过in判断

②get() 若key不存在可以返回None(Python交互环境不显示结果)/自己指定的value

'Thomas' in d
False

>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1

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

set

也是一组key的集合，但不存储value

重复的元素会在set中自动被过滤

add(key)方法添加元素到set中，可以重复添加元素，但是没有效果

remove(key)删除元素

二、函数

①调用函数

Ⅰ 求绝对值的函数abs

Ⅱmax()函数，可以接受多个参数，并返回最大的那个

Ⅲ 数据类型转换函数 int()将其他数据类型转换为整数

②定义函数

定义函数 在python中，定义一个函数要使用def语句，一次写出函数名、括号、括号中的参数和冒号：,然后写函数体，返回值用return

空函数 可以用pass语句

返回多个值

import math语句表示导入math包，并允许后续代码引用math里的sin,cos等函数

调用平方根函数 math.sqrt()

③函数的参数

位置参数

def power(x):
    return x * x

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

当我们调用power函数时，必须传入有且仅有的一个参数x

power(x,n)计算x的n次

x，n都是位置参数，调用函数时，传入的两个值按照顺序位置顺序一次赋给参数x和n

def power(x, n):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

默认参数

因为经常计算x2，可以把第二个参数n的默认值设定为2：

def power(x, n=2):
    s = 1
    while n > 0:
        n = n - 1
        s = s * x
    return s

这样，当我们调用power(5)时，相当于调用power(5, 2)：

>>> power(5)
25
>>> power(5, 2)
25

设置默认参数（能降低调用函数的难度）时，有几点要注意：

• 必选参数在前，默认参数在后
• 当函数有多个参数时，把变化大的参数放前面，变化小的参数放后面。变化小的参数就可以作为默认参数。

调用enroll()函数传入两个参数：

>>> enroll('Sarah', 'F')
name: Sarah
gender: F

如果要继续传入年龄、城市等信息怎么办？这样会使得调用函数的复杂度大大增加。

我们可以把年龄和城市设为默认参数：

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

这样，大多数学生注册时不需要提供年龄和城市，只提供必须的两个参数：

>>> enroll('Sarah', 'F')
name: Sarah
gender: F
age: 6
city: Beijing

只有与默认参数不符的学生才需要提供额外的信息：

enroll('Bob', 'M', 7)
enroll('Adam', 'M', city='Tianjin')

可变参数

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

定义可变参数和定义一个list或tuple参数相比，在参数前面加一个*号，调用该函数时，可以传入任意个参数，包括0个参数：

>>> calc(1, 2)
5
>>> calc()
0

关键字参数

关键字参数kw。在调用该函数时，可以只传入必选参数：

>>> person('Michael', 30)
name: Michael age: 30 other: {}

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

>>> 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'}

它可以扩展函数的功能。

命名关键字参数

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

调用方式如下：

>>> person('Jack', 24, city='Beijing', job='Engineer')
Jack 24 Beijing Engineer

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

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

命名关键字参数必须传入参数名，这和位置参数不同。如果没有传入参数名，调用将报错：

>>> person('Jack', 24, 'Beijing', 'Engineer')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: person() missing 2 required keyword-only arguments: 'city' and 'job'

如果没有可变参数，就必须加一个*作为特殊分隔符

任意函数，都可以通过类似func(*args, **kw)的形式调用它，无论它的参数是如何定义的。

④递归函数

使用递归函数的优点是逻辑简单清晰，缺点是过深的调用会导致栈溢出。

针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的，没有循环语句的编程语言只能通过尾递归实现循环。

Python标准的解释器没有针对尾递归做优化，任何递归函数都存在栈溢出的问题。