Python基础知识

最新推荐文章于 2024-08-29 10:04:09 发布

小小厨师长

最新推荐文章于 2024-08-29 10:04:09 发布

阅读量841

点赞数 19

文章标签： python 开发语言

本文链接：https://blog.csdn.net/cztl520/article/details/135047616

版权

Python学习笔记专栏收录该内容

1 篇文章 0 订阅

订阅专栏

整理Python基础知识，参考《Python编程从入门到实践》

1. 变量和简单数据类型

1.1 字符串

字符串就是一系列字符。在Python中，用引号括起的都是字符串，其中的引号可以是单引号，也可以是双引号

1.1.1 修改字符串大小写

# 单词首字母大写
str.title()
# 全部大写
str.upper()
# 全部小写
str.lower()

1.1.2 在字符串中使用变量

s1 = "a"
s2 = "b"
s3 = f"{s1} {s2}"
print(f"hello, {s3.title()}") # hello A B

注意：f字符串是Python 3.6引入的。如果你使用的是Python 3.5或更早的版本，需要使用format()方法，而非这种f语法。要使用方法format()，可在圆括号内列出要在字符串中使用的变量

s1 = "a"
s2 = "b"
s3 = "{} {}".format(s1, s2)
s4 = "{1} {0}".format(s1, s2)
print(s3)
print(s4)

1.1.3 删除空白

# 删除字符串末尾空白（str自身没有删除）
str.rstrip()
# 删除字符串开头空白（str自身没有删除）
str.lstrip()
# 删除字符串两边空白（str自身没有删除）
str.strip()

1.2 数

1.2.1 整数

1.2.2 浮点数

1.2.3 同时给多个变量赋值

x, y, z = 1, 2, 3

1.2.4 常量

常量类似于变量，但其值在程序的整个生命周期内保持不变。Python没有内置的常量类型，但Python程序员会使用全大写来指出应将某个变量视为常量，其值应始终不变

2. 列表

列表由一系列按特定顺序排列的元素组成，在Python中，用方括号（[]）表示列表，并用逗号分隔其中的元素

2.1 添加元素

末尾添加元素

list.append('xxx')

列表中插入元素

list.insert(0, 'xxx') # 在索引0处添加元素

2.2 删除元素

del语句删除元素

del list[0] # 删除索引0的元素

pop()删除末尾元素

aaa = list.pop() # 删除末尾元素，并赋值给 aaa 变量

pop()删除任意位置元素

aaa = list.pop(2) # 删除索引2处的元素，并赋值给 aaa 变量

根据值删除元素

list = ['honda', 'yamaha', 'suzuki', 'ducati']
list.remove('ducati')

2.3 组织列表

2.3.1 对列表排序

永久排序

list = ['aaa', 'bbb']
list.sort()

临时排序

list = ['aaa', 'bbb']
sorted(list)

2.3.2 倒序打印列表

list = ['aaa', 'bbb']
list.reverse() # 永久改变list顺序

2.4 创建数值列表

2.4.1 range()

for value in range(1, 5)

2.4.2 使用range()创建数值列表

nums = list(range(1, 11, 2)) # 2 步长

2.4.3 对数值列表进行简单统计计算

digits = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
min(digits)
0
max(digits)
9
sum(digits)
45

2.5 列表解析

列表解析将for循环和创建新元素的代码合并成一行，并自动附加新元素

squares = [value**2 for value in range(1, 11)]
print(squares)

3. 元组

元组看起来很像列表，但使用圆括号而非中括号来标识。定义元组后，就可使用索引来访问其元素，就像访问列表元素一样。元组内元素不可修改

aa = (12, 40)
bb = (20, )

严格地说，元组是由逗号标识的，圆括号只是让元组看起来更整洁、更清晰。如果你要定义只包含一个元素的元组，必须在这个元素后面加上逗号

4. 字典

在Python中，字典是一系列键值对。每个键都与一个值相关联，你可使用键来访问相关联的值。与键相关联的值可以是数、字符串、列表乃至字典。事实上，可将任何Python对象用作字典中的值。在Python中，字典用放在花括号（{}）中的一系列键值对表示。

dic1 = {'a' : 'b'}
dic2 = {1 : 'c'}
print(dic1['a'])
print(dic2[1])

4.1 添加键值对

字典是一种动态结构，可随时在其中添加键值对。要添加键值对，可依次指定字典名、用方括号括起的键和相关联的值。

dic1 = {'a' : 'b'}
dic2 = {1 : 'c'}
print(dic1['a'])
print(dic2[1])
dic1['aa'] = 'bb'
print(dic1)

4.2 删除键值对

对于字典中不再需要的信息，可使用del语句将相应的键值对彻底删除。使用del语句时，必须指定字典名和要删除的键

dic1 = {'a' : 'b'}
dic2 = {1 : 'c'}
print(dic1['a'])
print(dic2[1])
dic1['aa'] = 'bb'
print(dic1)
del dic1['aa']
print(dic1)

4.3 使用get()访问值

方法get()的第一个参数用于指定键，是必不可少的；第二个参数为指定的键不存在时要返回的值，是可选的

dic = {'aa': 'bb', 'cc': 'dd'}

ee = dic.get('ee', 'No ee value assigned.')
print(ee)

4.4 遍历字典

4.4.1 遍历所有键值对

dic = {'aa': 'bb', 'cc': 'dd'}

for k, v in dic.items():
    print(f"key: {k}")
    print(f"value: {v}")

4.4.2 遍历所有键

dic = {'aa': 'bb', 'cc': 'dd'}

# for k in dic:（默认遍历所有键）
for k in dic.keys():
    print(f"key: {k}")

4.4.3 按特定顺序遍历字典中的所有键

dic = {'ee': 'bb', 'cc': 'dd'}

for k in sorted(dic.keys()):
    print(f"key: {k}")

4.4.4 遍历字典中的所有值

dic = {'aa': 'bb', 'cc': 'dd', 'ee': 'dd'}

for v in dic.values():
    print(f"value: {v}")
    
print("="*10)
# 删除重复值
for v in set(dic.values()):
    print(f"value: {v}")

注意：可使用一对花括号直接创建集合，并在其中用逗号分隔元素

ss = {'a', 'b', 'c'}
print(ss)
print(type(ss))

4.5 嵌套

字典列表：列表元素为字典

在字典中存储列表

在字典中存储字典

5. 用户输入

5.1 input()工作原理

msg = input('please enter something: ')
age = int(input('How old are you? '))
print(msg)
print(age)

6. 函数

6.1 参数类型

6.1.1 位置实参

调用函数时，Python必须将函数调用中的每个实参都关联到函数定义中的一个形参。为此，最简单的关联方式是基于实参的顺序。这种关联方式称为位置实参

def describe_pet(animal_type, pet_name):
    """显示宠物的信息。"""
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")

describe_pet('hamster', 'harry')

6.1.2 关键字实参

关键字实参是传递给函数的名称值对。因为直接在实参中将名称和值关联起来，所以向函数传递实参时不会混淆。关键字实参让你无须考虑函数调用中的实参顺序，还清楚地指出了函数调用中各个值的用途。

def describe_pet(animal_type, pet_name):
    """显示宠物的信息。"""
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")

describe_pet(animal_type='hamster', pet_name='harry')
describe_pet(pet_name='harry', animal_type='hamster')

**注意：**使用关键字实参时，务必准确指定函数定义中的形参名

6.1.3 默认值

def describe_pet(pet_name, animal_type='dog'):
    """显示宠物的信息。"""
    print(f"\nI have a {animal_type}.")
    print(f"My {animal_type}'s name is {pet_name.title()}.")

describe_pet(pet_name='willie')

6.2 传递任意数量的实参

有时候，预先不知道函数需要接受多少个实参，Python允许函数从调用语句中收集任意数量的实参。

def make_pizza(*toppings):
    """打印顾客点的所有配料。"""
    print(toppings)

make_pizza('pepperoni')
make_pizza('mushrooms', 'green peppers', 'extra cheese')

形参名*toppings中的星号让Python创建一个名为toppings的空元组，并将收到的所有值都封装到这个元组中

6.3 传递任意数量的关键字实参

def build_profile(first, last, **user_info):
    """创建一个字典，其中包含我们知道的有关用户的一切。"""
    user_info['first_name'] = first
    user_info['last_name'] = last
    return user_info

user_profile = build_profile('albert', 'einstein',
                             location='princeton',
                             field='physics')
print(user_profile)
# {'location': 'princeton', 'field': 'physics', 'first_name': 'albert', 'last_name': 'einstein'}

函数build_profile()的定义要求提供名和姓，同时允许根据需要提供任意数量的名称值对。形参**user_info中的两个星号让Python创建一个名为user_info的空字典，并将收到的所有名称值对都放到这个字典中。在这个函数中，可以像访问其他字典那样访问user_info中的名称值对。

7. 类

7.1 创建类

class Dog:
    """一次模拟小狗的简单尝试。"""    
    def __init__(self, name, age):
        """初始化属性name和age。"""
        self.name = name
        self.age = age    
        
    def sit(self):
          """模拟小狗收到命令时蹲下。"""
          print(f"{self.name} is now sitting.")

    def roll_over(self):
          """模拟小狗收到命令时打滚。"""
          print(f"{self.name} rolled over!")

7.2 根据类创建实例

class Dog:
    """一次模拟小狗的简单尝试。"""    
    def __init__(self, name, age):
        """初始化属性name和age。"""
        self.name = name
        self.age = age    
        
    def sit(self):
          """模拟小狗收到命令时蹲下。"""
          print(f"{self.name} is now sitting.")

    def roll_over(self):
          """模拟小狗收到命令时打滚。"""
          print(f"{self.name} rolled over!")

my_dog = Dog('Willie', 6)
print(f"My dog's name is {my_dog.name}.")
print(f"My dog is {my_dog.age} years old.")

7.3 继承

首先是Car类的代码。创建子类时，父类必须包含在当前文件中，且位于子类前面。定义子类时，必须在圆括号内指定父类的名称。方法__init__()接受创建Car实例所需的信息。super()是一个特殊函数，让你能够调用父类的方法。这行代码让Python调用Car类的方法__init__()，让ElectricCar实例包含这个方法中定义的所有属性。父类也称为超类（superclass），名称super由此而来

class Car:
   """一次模拟汽车的简单尝试。"""
   def __init__(self, make, model, year):
       self.make = make
       self.model = model
       self.year = year
       self.odometer_reading = 0
   def get_descriptive_name(self):
       long_name = f"{self.year} {self.make} {self.model}"
       return long_name.title()
   def read_odometer(self):
       print(f"This car has {self.odometer_reading} miles on it.")
   def update_odometer(self, mileage):
       if mileage >= self.odometer_reading:
           self.odometer_reading = mileage
       else:
           print("You can't roll back an odometer!")
   def increment_odometer(self, miles):
       self.odometer_reading += miles

class ElectricCar(Car):
    """电动汽车的独特之处。"""
    def __init__(self, make, model, year):
        """初始化父类的属性。"""
        super().__init__(make, model, year)
my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())

7.3.1 重写父类方法

对于父类的方法，只要它不符合子类模拟的实物的行为，都可以进行重写。为此，可在子类中定义一个与要重写的父类方法同名的方法。这样，Python将不会考虑这个父类方法，而只关注你在子类中定义的相应方法

7.3.2 将实例用作属性

class Car:
    """一次模拟汽车的简单尝试。"""
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.odometer_reading = 0
    def get_descriptive_name(self):
        long_name = f"{self.year} {self.make} {self.model}"
        return long_name.title()
    def read_odometer(self):
        print(f"This car has {self.odometer_reading} miles on it.")
    def update_odometer(self, mileage):
        if mileage >= self.odometer_reading:
            self.odometer_reading = mileage
        else:
            print("You can't roll back an odometer!")
    def increment_odometer(self, miles):
       self.odometer_reading += miles
       
class Battery:
    """一次模拟电动汽车电瓶的简单尝试。"""
    def __init__(self, battery_size=75):
       """初始化电瓶的属性。"""
       self.battery_size = battery_size
    def describe_battery(self):
       """打印一条描述电瓶容量的消息。"""
       print(f"This car has a {self.battery_size}-kWh battery.")
       
class ElectricCar(Car):
    """电动汽车的独特之处。"""
    def __init__(self, make, model, year):
        """
        初始化父类的属性。
        再初始化电动汽车特有的属性。
        """
        super().__init__(make, model, year)
        self.battery = Battery()

my_tesla = ElectricCar('tesla', 'model s', 2019)
print(my_tesla.get_descriptive_name())
my_tesla.battery.describe_battery()

8. 文件

8.1 打开文件模式

t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（不推荐）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

8.2 方法

file.read([size])：size 未指定则返回整个文件，如果文件大小 >2 倍内存则有问题，f.read()读到文件尾时返回""(空字串)。
file.readline()：返回一行。
**file.readlines([size]) **：返回包含size行的列表, size 未指定则返回全部行。
**for line in f: print line **：通过迭代器访问。
f.write(“hello\n”)：如果要写入字符串以外的数据,先将它转换为字符串。
f.tell()：返回一个整数,表示当前文件指针的位置(就是到文件头的字节数)。
f.seek(偏移量,[起始位置])：用来移动文件指针。
- 偏移量: 单位为字节，可正可负
- 起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
f.close() 关闭文件

8.3 从文件中读取数据

with open('data.txt') as file_object:
    contents = file_object.read()
print(contents)

8.3.1 逐行读取

filename = 'data.txt'
with open(filename) as file_object:
    for line in file_object:
       print(line)

8.3.2 创建一个包含文件各行内容的列表

方法readlines()从文件中读取每一行，并将其存储在一个列表中。接下来，该列表被赋给变量lines

filename = 'data.txt'
with open(filename) as file_object:
     lines = file_object.readlines()
for line in lines:
    print(line.rstrip())

8.4 写入文件

8.4.1 写入空文件

调用open()时提供了两个实参。第一个实参也是要打开的文件的名称。第二个实参（‘w’）告诉Python，要以写入模式打开这个文件。打开文件时，可指定读取模式（‘r’）、写入模式（‘w’）、附加模式（‘a’）或读写模式（‘r+’）。如果省略了模式实参，Python将以默认的只读模式打开文件

filename = 'data.txt'
with open(filename, 'w') as file_object:
   file_object.write("I love data.")

8.5 json

8.5.1 使用json.dump()和json.load()

import json

numbers = [2, 3, 5, 7, 11, 13]

filename = 'nums.json'
with open(filename, 'w') as f:
    json.dump(numbers, f)

filename = 'nums.json'
with open(filename) as f:
    numbers = json.load(f)
    
print(numbers)