Day1：Python编程基础：数据类型、函数与类详解

Python作为一门简洁高效的编程语言，凭借其易读性语法和强大的功能库，已成为最受欢迎的编程语言之一。本文将从基础数据类型、函数和类三个核心要素入手，带您快速掌握Python编程的基础知识。

一、基础数据类型

1. 数值类型

# 整数，定义整数变量：int
age = 25

# 浮点数，定义浮点数变量：float
price = 9.99

# 布尔值，定义布尔变量：bool
is_valid = True

2.序列类型

1.字符串常用操作

（1）字符串的find(), index(), rfind(), rindex()方法：

# 字符串（不可变），定义字符串变量：Str
name = "我爱中国，祖国万岁，祖国繁荣昌盛"
    print(name.find("祖国"))      #find()用于查找子字符串，如果找到则返回第一个匹配的索引，否则find()返回-1
    print(name.index("祖国"))     #index()方法用于查找子字符串，如果找到则返回第一个匹配的索引，否则index()会抛出一个ValueError异常。
    print(name.rfind("祖国"))     #rfind()方法从字符串的末尾开始查找。
    print(name.rindex("祖国"))    #rindex()方法从字符串的末尾开始查找。
    print(name.count("国"))       # count()方法返回子字符串在字符串中出现的次数。
   	

#输出为：
5
5
10
10
3

（2）字符串capitalize()，upper()，lower()，swapcase()，title()的方法：

name = "i Love China"
    print(name.capitalize())    #首字母变为大写
    print(name.upper())         #将字符串转换为全部大写。
    print(name.lower())         #将字符串转换为全部小写。
    print(name.swapcase())      #将字符串中的小写字符转换为大写或大写字符转换为小写。
    print(name.title())         #将字符串中的单词首字母转换为大写

输出为：
I love china
I LOVE CHINA
i love china
I lOVE cHINA
I Love China

（3）字符串center()，ljust()，rjust()，zfill()的方法：

name = "我爱中国"
    print(name.center(20,"="))  #返回一个原字符串在中间，并使用fillchar（默认为空格）填充左边和右边形成一个新字符串
    print(name.ljust(20,"="))   #返回一个原字符串左对齐，并使用fillchar（默认为空格）填充至指定宽度的新字符串。
    print(name.rjust(20,"="))   #返回一个原字符串右对齐，并使用fillchar（默认为空格）填充至指定宽度的新字符串。
    print(name.zfill(20))       #返回字符串左端填充零直到长度为width的字符串。

输出为：
++++++++我爱中国++++++++
我爱中国================
================我爱中国
0000000000000000我爱中国

（4）字符串的startswith()和endswith()方法：

name = "我爱中国，祖国万岁，祖国繁荣昌盛"
    print(name.startswith("我爱"))    #检查字符串是否以指定的前缀开始，如果是输出True,否则输出False。
    print(name.startswith("昌盛"))
    print(name.endswith("我爱"))      #检查字符串是否以指定的前缀开始，如果是输出True,否则输出False。
    print(name.endswith("昌盛"))

输出为：
True
False
False
True

（5）字符串的encode()和decode()方法:

byte_result = "我爱中国，祖国万岁，祖国繁荣昌盛".encode(encoding='gbk') #将字符串编码成字节串，通常用于写入文件或网络传输。
    print(type(byte_result),byte_result)
    byte_result = byte_result.decode(encoding='gbk')    #将字节串解码成字符串，是encode()的逆操作。
    print(type(byte_result),byte_result)

输出为：
<class ‘bytes’> b’\xce\xd2\xb0\xae\xd6\xd0\xb9\xfa\xa3\xac\xd7\xe6\xb9\xfa\xcd\xf2\xcb\xea\xa3\xac\xd7\xe6\xb9\xfa\xb7\xb1\xc8\xd9\xb2\xfd\xca\xa2’
<class ‘str’> 我爱中国，祖国万岁，祖国繁荣昌盛

(6)字符串的split()和join(),replace()方法:

name = "我爱中国，祖国万岁，祖国繁荣昌盛"
    print(type(name),name)
    print(type(name.split("祖国万岁")),name.split("祖国万岁"))  #根据指定的分隔符将字符串分割出来。
    print("==".join(name.split("祖国万岁")))        #将裁剪出来的中的元素进行替换连接成一个字符串。
    print(name.replace("祖国万岁","祖国更好"))  #替换字符串中的某些字符或子字符串。

输出为：
<class ‘str’> 我爱中国，祖国万岁，祖国繁荣昌盛
<class ‘list’> [‘我爱中国，’, ‘，祖国繁荣昌盛’]
我爱中国，==，祖国繁荣昌盛
我爱中国，祖国更好，祖国繁荣昌盛

（7）字符串isalpha(), isdigit(), isalnum(),islower(), isupper()方法：

	print("aAbB".isalpha())     #检查字符串是否只由字母组成。
    print("123456".isdigit())   #检查字符串是否只由数字组成。
    print("123abc".isalnum())   #检查字符串是否只由字母和数字组成。
    print("abcdefgh".islower()) #检查字符串是否全是小写字母。
    print("ABCDEF".isupper())   #检查字符串是否全是大写字母。

输出为：
True
True
True
True
True

（8）字符串方法：strip(), lstrip(), rstrip()方法:

name = "====hello kitty===="
    print(name.strip("="))  #去除字符串两端的空白字符（包括空格、换行符\n、制表符\t等），也可以指定,默认是空格
    print(name.lstrip("=")) #lstrip()用于去除左端的空白字符,默认是空格
    print(name.rstrip("=")) #rstrip()用于去除右端的空白字符,默认是空格

输出结果为：
hello kitty
hello kitty====
====hello kitty

2.列表的常见操作：

（1）添加元素

# 列表（可变），列表的定义：list
colors = ["red", "green", "blue"]
colors.append("yellow")		#表示往colors列表表末尾添加一个元素。
colors.insert(1, "block")	#表示往colors列表的指定位置插入一个元素。
colors1 = ["pick","skyblue"]
colors.extend(colors1)		#表示往colors列表的尾部加入colors1中的所有元素。
print(colors)

输出结果为：[‘red’, ‘block’, ‘green’, ‘blue’, ‘yellow’, ‘pick’, ‘skyblue’]

（2）删除元素

	colors = ["red", "block","yellow","green", "blue","pick","skyblue"]
    colors.remove("green")  #删除指定的值，如果之不存在 则报错
    print(colors)
    colors.pop(0)   #可以删除指定索引对应的元素返回被删除的元素，默认删除最后一位
    print(colors)
    colors.clear()    #清空列表
    print(colors)

输出结果分别是：
[‘red’, ‘block’, ‘yellow’, ‘blue’, ‘pick’, ‘skyblue’]
[‘block’, ‘yellow’, ‘blue’, ‘pick’, ‘skyblue’]
[]

（3）列表的其他操作:

list = [1,2,3,4,5,4,3,2,1,9,8,7,6,0]
    print(list.index(9))    #index 通过元素的值 获取元素的下标索引
    print(list.count(1))    #count 获取元素出现的次数
    list.reverse()   #reverse()方法反转列表中的元素， 逆序
    print(list)
    list.sort(reverse=False)     #sort()方法排序(默认为True升序）
    print(list)
    print(5 in list)    #in （存在）, 如果存在那么结果为true，否则为false

输出结果为：
9
2
[0, 6, 7, 8, 9, 1, 2, 3, 4, 5, 4, 3, 2, 1]
[0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 6, 7, 8, 9]
True

3.Tuple（元组）

元组（Tuple）是Python中的一种内置数据类型，用于存储一系列有序的元素。与列表（List）相似，但元组是不可变的（immutable），即一旦创建，就不能修改其内部的元素。元组使用圆括号()来定义，元素之间用逗号,分隔。如果元组中只有一个元素，需要在该元素后面加上逗号,，以区分于该元素本身和元组。

tuple_list = tuple(range(10))   #用tuple将range数组转换为元组
    tuple_list_all = (10,"hello",True,None,tuple_list)
    for i in tuple_list_all:    #遍历元组
        print(i)
    print("hello" in tuple_list_all)    #使用in关键字可以检查一个元素是否在元组中,存在返回True
    print(len(tuple_list_all))          #使用len()函数可以获取元组中元素的数量。这里tuple_list只被算成一个函数。

输出结果为：
10
hello
True
None
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
True
5

3. 映射类型

1.字典的定义

字典（Dictionary）是Python中一种用于存储键值对（key-value pair）的数据结构。每个键（key）都与一个值（value）相关联，键必须是唯一的，但值可以是任意数据类型（如整数、字符串、列表、甚至其他字典）。字典的创建使用花括号 {}，每个键值对使用冒号 : 分隔，键和值之间使用逗号 , 分隔。

# 字典（键值对）
person = {
    "name": "Bob",
    "age": 30,
    "hobbies": ["reading", "coding"]
}
print()  

输出结果为：
{‘name’: ‘Bob’, ‘age’: 30, ‘hobbies’: [‘reading’, ‘coding’]}

2.字典的常见操作

1.对字典中的值进行增删改查操作

person = {
        "name": "Bob",
        "age": 30,
        "hobbies": ["reading", "coding"]
    }
    print(person)
    print(person["age"])    #查询字典中age字段的键对应的值
    person["age"]  = 40     #修改age字段的键对应的值
    print(person["age"])    
    person["sex"] = "男"     #新增一个sex的键值对
    print(person["sex"])
    person.pop("name")      #删除一个name的键值对
    print(person)
    print("sex" in person)  #使用 in 关键字检查字典中是否存在指定的键.

输出结果为：
{‘name’: ‘Bob’, ‘age’: 30, ‘hobbies’: [‘reading’, ‘coding’]}
30
40
男
{‘age’: 40, ‘hobbies’: [‘reading’, ‘coding’], ‘sex’: ‘男’}
True

2.使用 keys() 方法获取所有键，使用 values() 方法获取所有值，使用get()访问值：

person = {
        "name": "Bob",
        "age": 30,
        "hobbies": ["reading", "coding"]
    }
    for key in person.keys():   #使用 keys() 方法获取所有键
        print(key)
    print("=="*10)
    for value in person.values():   #使用 values() 方法获取所有值
        print(value)
    print("==" * 10)
    print(person.get("name"))   #使用get()访问值,当指定键不存在时返回None
    print(person.get("sex"))

输出结果为：
name
age
hobbies
====================
Bob
30
[‘reading’, ‘coding’]
====================
Bob
None

4. 集合类型

1.集合的定义

在Python中，集合（Set）是一种无序且元素唯一的数据集合。集合通常用于去重或者检查成员是否存在，其元素可以是任何不可变的数据类型，比如整数、浮点数、字符串或元组。集合使用花括号 {} 来创建，元素之间使用逗号 , 分隔。

2.集合的基础操作

	set_null = set()    #只能通过set来定义空集合
    set_only = {1,3,2,4,5,4,3,2,1}
    print(set_only)     #集合是无序的，里面的元素是唯一的，集合中的数字会自动从小到大排序
    set_null.add(8)     #使用 add()方法向集合中添加单个元素。
    print(set_null)
    set_null.update({1,2,3,4,5})    #使用update（）方法向集合中添加单个元素。
    print(set_null)
    set_delect = {"red","blue","green","yellow","white","black","sliver","pick"}
    set_delect.pop()      #括号中不写东西，表示随机删除其中一个元素
    print(set_delect)
    set_delect.remove("yellow")     #根据元素的值进行删除
    print(set_delect)
    set_delect.discard("red")       #根据元素的值进行删除，不存在所删除的值时不会报错
    print(set_delect)

输出结果为：
{1, 2, 3, 4, 5}
{8}
{1, 2, 3, 4, 5, 8}
{‘pick’, ‘black’, ‘yellow’, ‘white’, ‘blue’, ‘red’, ‘sliver’}
{‘pick’, ‘black’, ‘white’, ‘blue’, ‘red’, ‘sliver’}
{‘pick’, ‘black’, ‘white’, ‘blue’, ‘sliver’}

3.集合运算：集合支持常见的集合运算，如并集、交集、差集等。

set_num1 = {1,2,3}
    set_num2 = {1,4,5,6}
    set_sum = set_num1.union(set_num2)      #并集：使用 union() 方法或 | 运算符。
    set_sum = set_num1 | set_num2
    print(set_sum)
    set_sum = set_num1.intersection(set_num2)   #使用 intersection() 方法或 & 运算符。
    set_sum = set_num1 & set_num2
    print(set_sum)
    set_sum = set_num1.difference(set_num2)     #使用 difference() 方法或 - 运算符。
    set_sum = set_num1 - set_num2
    print(set_sum)
    print(set_num1.clear())     #使用 clear() 方法清空集合中的所有元素。

输出结果为：
{1, 2, 3, 4, 5, 6}
{1}
{2, 3}
None

总结

在Python中，数据类型可以分为可变（mutable）和不可变（immutable）两种类型：

可变数据类型：

• List（列表）：列表可以通过添加、删除或更改元素来改变其内容。
• Dict（字典）：字典中的键和值可以被添加、删除或修改。
• Set（集合）：集合支持添加、删除和更新操作。

不可变数据类型：

• Int（整数）整数是不可变类型，一旦创建就不能更改其值。
• Float（浮点数）：浮点数也是不可变的。
• Bool（布尔值）：布尔值 True 和 False 是不可变的。
• Str（字符串）：字符串一旦创建就不能被修改，可以通过切片和拼接来创建新的字符串。
• Tuple（元组）：元组是不可变的，一旦创建就不能更改其内容。

可变性的概念在于是否允许对象在被创建后修改其值或结构。可变对象可以在运行时改变其值或内容，而不可变对象在创建后保持不变

二、函数：代码复用的艺术

1. 函数定义

def greet(name, times=1):
    """打印多次问候语"""
    for _ in range(times):
        print(f"Hello, {name}!")
if __name__ == '__main__':
    greet("中国")

输出结果为：
Hello, 中国!

2. 参数类型

def greet(name, times=1):   #定义时小括号中的参数，括号内的“name”就是形参。带有默认值的参数一定要位于参数列表的最后面。
    """打印多次问候语"""
    for _ in range(times):  #调用函数时，缺省参数的值如果没有传入，则取默认值。例如，这里的times就取默认值1
        print(f"Hello, {name}!")
"""
    有时可能需要一个函数能处理比当初声明时更多的参数, 这些参数叫做不定长参数，声明时不会命名。
        1.加了星号（*）的变量args会存放所有未命名的变量参数，args为元组
        2.而加**的变量kwargs会存放命名参数，即形如key=value的参数， kwargs为字典.
        3.缺省参数在*args后面
"""
def fun(a, b, *args,name="姚明", **kwargs):
    print("a =%d" % a)
    print("b =%d" % b)
    print("args:")
    print(args)
    print("kwargs: ")
    print(name)
    for key, value in kwargs.items():
        print("key=%s" % value)
if __name__ == '__main__':
    greet("中国")        #调用时小括号中的参数，这里的“中国”就是实参
    fun(1, 2, 3, 4, 5, m=6, n=7, p=8)

输出结果为：
Hello, 中国!
a =1
b =2
args:
(3, 4, 5)
kwargs:
姚明
key=6
key=7
key=8

3. 返回值

def create_nums(num):
    print("---1---")
    if num == 10:
        print("---2---")
        return num + 1  # 函数中下面的代码不会被执行，因为return除了能够将数据返回之外，还有一个隐藏的功能：结束函数
    else:
        print("---3---")
        return num + 2

if __name__ == '__main__':
    create_nums(10)

输出结果为：
– --1-- –
– --2-- –

4. 作用域规则

count = 10  # 全局变量
def modify_count():
    global count
    num = 5     #局部变量
    count += num
    print(count)
if __name__ == '__main__':
    modify_count()

5. 总结

• 无参数、无返回值

def 函数名():
    语句

• 无参数、有返回值

def 函数名():
    语句
    return 需要返回的数值

一个函数到底有没有返回值，就看有没有return，因为只有return才可以返回数据,在开发中往往根据需求来设计函数需不需要返回值,函数中，可以有多个return语句，但是只要执行到一个return语句，那么就意味着这个函数的调用完成

• 有参数、无返回值

def 函数名(形参列表):
    语句

• 有参数、有返回值

def 函数名(形参列表):
    语句
    return 需要返回的数值

• 调用函数

调用的方式为：
函数名([实参列表])

• 如果调用的函数 在定义时有形参，那么在调用的时候就应该传递参数。
• 调用时，实参的个数和先后顺序应该和定义函数中要求的一致。
• 如果调用的函数有返回值，那么就可以用一个变量来进行保存这个值

• 作用域

• 在一个函数中定义的变量，只能在本函数中用(局部变量)
• 在函数外定义的变量，可以在所有的函数中使用(全局变量)

三、类与面向对象编程

1. 类的基本结构

class Dog:
    # 类属性
    species = "Canis familiaris"

    # 初始化方法
    def __init__(self, name, age):
        self.name = name  # 实例属性
        self.age = age

    # 实例方法
    def bark(self):
        print(f"{self.name} says: Woof!")

# 创建实例
my_dog = Dog("Buddy", 3)
my_dog.bark()  # 输出: Buddy says: Woof!

2. 继承与多态

class GoldenRetriever(Dog):
    def fetch(self, item):
        print(f"{self.name} fetches {item}!")

    # 方法重写
    def bark(self):
        print("Woooooof!")

3. 特殊方法

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    # 运算符重载
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    
    # 字符串表示
    def __str__(self):
        return f"Vector({self.x}, {self.y})"

4. 类方法与静态方法

class MyClass:
    @classmethod
    def class_method(cls):
        print(f"类方法被调用，类名：{cls.__name__}")

    @staticmethod
    def static_method():
        print("静态方法被调用")

四、最佳实践建议

1.​数据类型选择：

• 需要修改数据时选择列表
• 存储配置信息优先使用字典
• 确保数据安全时使用元组

2.​函数设计原则：

• 单一职责原则（一个函数只做一件事）
• 函数长度不超过一屏显示
• 使用类型注解提高可读性

3.​类设计技巧：

• 优先组合而非继承
• 使用属性装饰器管理属性访问
• 遵循PEP8命名规范

结语

掌握Python的基础数据类型、函数和类，就像获得打开Python世界的三把钥匙。通过本文的讲解和示例代码，您可以

• 合理选择数据类型存储信息
• 通过函数封装重复逻辑
• 使用面向对象思想构建复杂系统

建议结合具体项目实践，逐步深入理解这些概念。当您能灵活运用这三个核心要素时，就能编写出高效、易维护的Python程序了！