Python基础

1.数据类型

1）int

任意精度整数，支持如下运算：

x ** y : $x^y$

x // y : $\left\lfloor \frac{x}{y} \right\rfloor$

x / y一定返回浮点数，4 / 2 = 2.0

2）float

浮点数有范围限制，最大约为1e308

双精度浮点数大约有15~17位有效十进制位

float('inf')    # 正无穷
float('-inf')   # 负无穷
float('nan')    # 非数值

3）complex

复数 z = 1 + 2j

4）bool

b = True 或 b = False

5）str

字符串不区分“”和‘’

str为不可变元素，无法操作s[0] = '1'这样的赋值

6）list

a = [1, 2, 3, 4]
a = [1, "hello", True]

列表内元素属性可以不同

a[0] #访问元素

列表可以修改：

a[0] = 100

因此列表是可变对象（区别于str

常见操作：

a.append(5) #在列表末尾加一个5
a.pop() #删除并返回列表最后一个元素
a.pop(0) #删除下标为0的元素

a.sort() #如果类型不同，需要a.sort(key=...),key=str就按照unicode码点
a.reverse()

7）tuple

a = (1, 2, 3)

与列表比较相似，但元组不能修改。

a[0] = 10

会报错。

8）set

集合最大的特点：

元素不重复。

a = {1, 2, 3}

如果：

a = {1, 1, 2, 2, 3}

实际得到：

{1, 2, 3}

非常适合：

去重
判断元素是否存在
集合运算

例如：

1 in a # 对列表也可以使用

集合运算：

A | B   # 并集
A & B   # 交集
A - B   # 差集

9）dict

字典是键到值的对应关系。

例如：

student = {    
"name": "Tom",    
"age": 18
}

访问：

student["name"]

得到：

Tom

修改：

student["age"] = 19

增加：

student["score"] = 100

在算法里，字典经常用来做：

计数
映射
哈希表

例如：

cnt = {}
for x in a:    
  cnt[x] = cnt.get(x, 0) + 1
#在cnt中寻找x对应的值，如果没有就返回0

2.字符串操作

1）`len`

输出字符串长度

a = len('python')
# a = 6

2）`s[i]`

获取字符串中第 i 个字符，下标从 0 开始

s = 'python'a = s[1]# a = 'y'

3）字符串切片 `[start:end:step]`

切片用于获取字符串的一部分

s[start:end:step]

其中：

start   起始下标
end     结束下标，不包含 end
step    步长

例如

s = 'abcdef'
a = s[1:4]
# a = 'bcd'

省略 start

a = s[:3]
# a = 'abc'

省略 end

a = s[3:]
# a = 'def'

全部取出

a = s[:]
# a = 'abcdef'

设置步长

a = s[::2]
# a = 'ace'，每次取完一个跳过两个

从下标 1 开始，每隔一个取一个

a = s[1::2]
# a = 'bdf'

反转字符串

a = s[::-1]
# a = 'fedcba'

从右往左每隔一个取一个

a = s[::-2]
# a = 'fdb'

使用负下标

s = 'python'
a = s[-3:]
# a = 'hon'

常见写法

s[:]       
# 整个字符串
s[:3]      
# 前3个字符s[3:]      
# 从下标3到最后
s[-3:]     
# 后3个字符
s[:-1]     
# 除最后一个字符
s[::2]     
# 每隔一个取一个
s[::-1]    
# 反转字符串

4）`+`

拼接两个字符串

a = 'hello' + 'world'
# a = 'helloworld'

5）`*`

重复字符串

a = 'ab' * 3
# a = 'ababab'

*还可以用于序列解包

比如

a, *b = [1, 2, 3, 4]

结果是：

a == 1
b == [2, 3, 4]

这里 *b 的意思就是把剩余所有的内容分配给b

6）`in`

判断字符串中是否包含某个字符或子串

a = 'th' in 'python'
# a = True

7）`find`

查找子串第一次出现的位置，找不到返回 -1

a = 'python'.find('th')
# a = 2

a = 'python'.find('abc')
# a = -1

8）`count`

统计字符或子串出现的次数

a = 'banana'.count('a')
# a = 3

9）`replace`

将字符串中的某部分替换为新的内容

a = 'hello world'.replace('world', 'python')
# a = 'hello python'

10）`split`

按照空白字符分割字符串，返回列表

a = 'hello python world'.split()
# a = ['hello', 'python', 'world']

11）`split(',')`

按照指定字符分割字符串

a = 'a,b,c'.split(',')# a = ['a', 'b', 'c']

12）`join`

将字符串列表拼接成一个字符串

a = ''.join(['a', 'b', 'c'])
# a = 'abc'

也可以指定连接符

a = '-'.join(['a', 'b', 'c'])
# a = 'a-b-c'

13）`strip`

删除字符串两端的空格、换行等空白字符

a = '  python  '.strip()
# a = 'python'

14）`lower`

将字符串中的英文字母全部转换为小写

a = 'PyThOn'.lower()# a = 'python'

15）`upper`

将字符串中的英文字母全部转换为大写

a = 'python'.upper()# a = 'PYTHON'

16）`f-string`

将变量或表达式插入字符串

name = 'Tom'
age = 18
a = f'{name} is {age} years old'
# a = 'Tom is 18 years old'

花括号中可以直接计算表达式

x = 10
y = 20
a = f'{x} + {y} = {x + y}'
# a = '10 + 20 = 30'

也可以控制小数位数

x = 3.1415926
a = f'{x:.2f}'
# a = '3.14'

17）转义符与字符串内换行

转义符用 \ 表示一些特殊字符

\n   
# 换行
\t   
# 制表符（输出一个tab间隔，让后面的文字对齐
\\   
# 表示 \
\'   
# 表示单引号
\"   
# 表示双引号

例如换行

a = 'hello\nworld'
# 输出：
# hello
# world

字符串中包含引号

a = 'I\'m Tom'
# 实际是 "I'm Tom"

字符串中包含反斜杠

a = 'C:\\Users\\Tom'
# a = 'C:\Users\Tom'

也可以用三引号直接写多行字符串

a = '''helloworldpython'''

如果不希望 \n、\t 等被解释为转义符，可以使用原始字符串 r''

a = r'hello\nworld'
# print(a)输出hello\nworld，不再换行

3.迭代器用法

1）什么是迭代器

你可以先把迭代器理解成：

一个“记住自己取到哪里了”的对象，可以一个一个往后取值。

a = [10, 20, 30]
it = iter(a)

it 就是一个迭代器

next(it)

可以依次对it取值（惰性计算

a = [10, 20, 30]
it = iter(a)
print(next(it))
print(next(it))
print(next(it))

输出：

10
20
30

2）`iter()`

iter() 的作用就是：把一个“可迭代对象”变成迭代器。

例如列表：

a = [1, 2, 3]
it = iter(a)

字符串也可以：

s = "abc"
it = iter(s)
print(next(it))
print(next(it))

元组也可以：

t = (5, 6, 7)
it = iter(t)

list, tuple, str都是可迭代对象

3）`for` 循环本质上就在用迭代器

例如：

for x in [10, 20, 30]:    
  print(x)

Python 内部逻辑可以近似理解成：

it = iter([10, 20, 30])
while True:
    try:
        x = next(it)
        print(x)
    except StopIteration:        
        break

所以for i in xxx: 能否使用的核心是看xxx是不是可迭代元素

4）生成器也是迭代器

例如：

def countdown(n):
    while n > 0:
        yield n #创建生成器，每次迭代的时候运行到有一个输出
        n -= 1

调用：

g = countdown(3)

g 是一个生成器，同时也是迭代器（countdown函数返回生成器对象，是迭代器

所以：

print(next(g))
print(next(g))
print(next(g))

输出：

3
2
1

也可以：

for x in countdown(3):
    print(x)

输出：

3
2
1

5）`map`

基本格式：

map(function, iterable)

意思是从 iterable 里一个一个取元素，然后交给 function 处理。

例如：

m = map(int, ["10", "20", "30"])

这里 m 是一个 map 迭代器。

它还没有立刻把所有东西算完。

6）list

如果你想一次看到所有结果：

m = map(lambda x: x * 2, [1, 2, 3])

print(list(m))

输出：

[2, 4, 6]

list() 做的事情可以理解成：

不断 next(m)
直到没有元素
然后全部放进 list

所以：

list(map(int, ["1", "2", "3"]))

得到：

[1, 2, 3]

7）`map` 最经典的输入用法

a, b = map(int, input().split())

假设输入：

10 20

第一步：

input()

得到：

"10 20"

第二步：

input().split()

得到：

["10", "20"]

第三步：

map(int, ["10", "20"])

得到一个迭代器：

map对象
   ↓
可以依次产生
10
20

最后：

a, b = ...

左边会把迭代器解包。

近似相当于：

m = map(int, input().split())
a = next(m)
b = next(m)

所以最终：

a == 10
b == 20

可迭代对象
   ↓
iter()
   ↓
迭代器
   ↓
next()
   ↓
一个一个取值

4.Python class 基础用法

class 用于定义一个类。可以把“类”理解成创建对象的模板。

class Student:
    pass

这里定义了一个 Student 类，可以通过：

s1 = Student()
s2 = Student()

创建两个对象。s1 和 s2 都属于 Student 类，但它们是两个独立的对象。

1）对象属性

对象可以拥有自己的属性：

class Student:
    pass

s1 = Student()
s1.name = "Alice"
s1.age = 18

print(s1.name)
print(s1.age)

输出：

Alice
18

通常不会在创建对象后再手动添加属性，而是使用 __init__ 统一初始化。

2）`init`

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

创建对象：

s1 = Student("Alice", 18)
s2 = Student("Bob", 20)

此时：

print(s1.name)  # Alice
print(s2.name)  # Bob

__init__ 是对象创建时自动调用的初始化方法。

s1 = Student("Alice", 18)

可以近似理解成：

Student.__init__(s1, "Alice", 18)

3）`self`

self 表示当前正在操作的对象。

例如：

class Student:
    def __init__(self, name):
        self.name = name

当执行：

s1 = Student("Alice")

此时 self 就是 s1，所以：

self.name = name

相当于：

s1.name = "Alice"

如果：

s2 = Student("Bob")

那么这次 self 就是 s2。

可以记住一句话：谁调用方法，self 就是谁。

4）方法

类里面定义的函数通常叫做方法。

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"我叫 {self.name}，今年 {self.age} 岁")

使用：

s1 = Student("Alice", 18)
s1.introduce()

输出：

我叫 Alice，今年 18 岁

调用：

s1.introduce()

可以近似理解为：

Student.introduce(s1)

所以虽然定义时需要写：

def introduce(self):

调用时不需要手动传入 self，Python 会自动把 s1 传进去。

5）修改对象属性

方法可以直接修改当前对象的数据：

class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def birthday(self):
        self.age += 1

使用：

s1 = Student("Alice", 18)

s1.birthday()

print(s1.age)

输出：

6）实例属性

像：

self.name
self.age

这种属性叫实例属性，每个对象都有自己独立的一份。

class Student:
    def __init__(self, name):
        self.name = name

a = Student("Alice")
b = Student("Bob")

此时：

a.name  # Alice
b.name  # Bob

修改 a.name 不会影响 b.name。

7）类属性

直接写在类里面、方法外面的变量叫类属性。

class Student:
    school = "ZJU"

    def __init__(self, name):
        self.name = name

可以：

print(Student.school)

也可以：

s1 = Student("Alice")
print(s1.school)

类属性通常用于保存所有对象共享的数据，而实例属性用于保存每个对象自己的数据。

Student.school → 所有对象共享
self.name      → 每个对象独立

8）对象之间可以互相传递

class Player:
    def __init__(self, name, hp):
        self.name = name
        self.hp = hp

    def attack(self, enemy): #使用a.attack(b)时自动把a传入self
        enemy.hp -= 10

创建两个对象：

a = Player("Alice", 100)
b = Player("Bob", 100)

执行：

a.attack(b)

这里：

self  = a
enemy = b

所以：

enemy.hp -= 10

实际上修改的是：

b.hp -= 10

最终 b.hp == 90。

9）继承

一个类可以继承另一个类：

class Animal:
    def speak(self):
        print("动物叫")

class Dog(Animal):
    pass

使用：

d = Dog()
d.speak()

输出：

动物叫

虽然 Dog 中没有定义 speak()，但它继承了 Animal 的方法。

10）方法重写

子类可以重新定义父类的方法：

class Animal:
    def speak(self):
        print("动物叫")

class Dog(Animal):
    def speak(self):
        print("汪汪")

执行：

d = Dog()
d.speak()

输出：

汪汪

这种行为叫方法重写。

11）`super()`

super() 常用于调用父类的方法。

class Animal:
    def __init__(self, name):
        self.name = name

class Dog(Animal):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age

创建：

d = Dog("旺财", 3)

执行：

super().__init__(name)

相当于先让父类完成：

self.name = name

然后子类再执行：

self.age = age

最终：

d.name  # 旺财
d.age   # 3

分享

1.数据类型

1）int

2）float

3）complex

4）bool

5）str

6）list

7）tuple

8）set

9）dict

2.字符串操作

1）len

2）s[i]

3）字符串切片 [start:end:step]

4）+

5）*

6）in

7）find

8）count

9）replace

10）split

11）split(',')

12）join

13）strip

14）lower

15）upper

16）f-string

17）转义符与字符串内换行

3.迭代器用法

1）什么是迭代器

2）iter()

3）for 循环本质上就在用迭代器

4）生成器也是迭代器

5）map

6）list

7）map 最经典的输入用法

4.Python class 基础用法

1）对象属性

2）__init__

3）self

4）方法

5）修改对象属性

6）实例属性

7）类属性

8）对象之间可以互相传递

9）继承

10）方法重写

11）super()

评论

1）`len`

2）`s[i]`

3）字符串切片 `[start:end:step]`

4）`+`

5）`*`

6）`in`

7）`find`

8）`count`

9）`replace`

10）`split`

11）`split(',')`

12）`join`

13）`strip`

14）`lower`

15）`upper`

16）`f-string`

2）`iter()`

3）`for` 循环本质上就在用迭代器

5）`map`

7）`map` 最经典的输入用法

2）`init`

3）`self`

11）`super()`