Python入门

一、Python介绍与安装

二、Python基本语法

三、Python数据类型

Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。
在 Python 中，变量就是变量，它没有类型，我们所说的"类型"是变量所指的内存中对象的类型。

1、基本数据类型

下面介绍一下 python3 中常见的数据类型：

# number
a, b, c = 1, 2.22, 1+2j
print(type(a), type(b), type(c))

# 字符串
name = "小李"
print(name)

# bool
isDel = True
print(isDel)

# 列表
total = [1, 2, 3.33, 5, 7, 'hhh']
# r 转义特殊符号
str1 = r'1231\414'

total[1] = 'c1'
print(total)
print("2 / 4 = " + str(2 / 4))
# 从第一个字符到第四个
print(str1[0:4])

# 元组
tupleTest = (1, 2.1, 'snow', [4, 5, 6])
'''
元组无法修改,会报错 TypeError: 'tuple' object does not support item assignment
tupleTest[0] = 2 
但是元组中的列表可以修改
'''
tupleTest[-1][0] = 7
print(tupleTest)

# 集合(自动去重)
setTest = {"111", 3.33, 111, 3.33, 4.56}
print(setTest)

# 字典(键值对)
dictTest = {1: "value1", 2: "value2", 3: "value3"}
print("获取所有的键：", dictTest.keys())
print("key 1的值为" + dictTest[1])

Number（数字）

String（字符串）

Bool（布尔类型）

List（列表）

Tuple（元组）

Set（集合）

Dictionary（字典）

2、数据类型分类

python中数据类型可分为可变类型和不可变类型。

• 不可变类型：一旦创建，就不能修改其值。常见的不可变类型包括数字(Number)、布尔值（bool）、字符串（str）、元组（tuple） 等。当我们重新赋值时。相当于新创建了一个对象。

• 可变类型：创建后可以修改其值。常见的可变类型包括列表（list）、集合（set）、字典（dict）等。

# 不可变类型
a = 5
b = "Hello, world!"
c = (1, 2, 3)

# 尝试修改不可变类型
a = 6  # 修改整数类型
b = "Goodbye, world!"  # 修改字符串类型
c[0] = 4  # 尝试修改元组类型,会报错 TypeError: 'tuple' object does not support item assignment

# 可变类型
lst = [1, 2, 3]
s = {1, 2, 3}
d = {"name": "Tom", "age": 18}

# 修改可变类型
lst[0] = 4  # 修改列表类型
s.add(4)  # 修改集合类型
d["age"] = 19  # 修改字典类型

3、数据类型转换

Python中的类型转换分为两种：显示转换、隐式转换。

类型获取及判断

我可以可以使用下面两种方式来获取数据的类型并进行判断：

• type() 函数
  可以返回一个对象的类型。

a, b, c = 1, 2.22, 1+2j
# 打印结果：<class 'int'> <class 'float'> <class 'complex'>
print(type(a), type(b), type(c))

• isinstance() 函数
  可以判断一个对象是否为指定类型。

a, b, c = 1, 2.22, 1+2j
isEquals = isinstance(a, int)
# 打印结果：True
print(isEquals)

type 函数 和 isinstance 函数区别：

type() 函数只能判断对象的实际类型，而 isinstance() 函数可以判断对象是否为指定类型或其子类的实例。

隐式类型转换

在隐式类型转换中，Python 会自动将一种数据类型转换为另一种数据类型，不需要我们去干预。

比如一个浮点数与整数相加，结果会自动转为浮点数，因为浮点数的数据大一些。

# 隐式转换
num1 = 1.233
num2 = 2
result = num1 + num2
print(type(result))

显示类型转换

在显式类型转换中，用户可以将对象的数据类型转换为所需的数据类型。 我们使用 int()、float()、str() 等预定义函数来执行显式类型转换。

# 如果直接与字符类型相加会报错：unsupported operand type(s) for +: 'int' and 'str'
num3 = 1
str3 = "4"
str_result = num3 + str3
print(str_result)

# 可以通过函数进行强制转换
str_result = num3 + int(str3)

四、条件判断

条件判断就是可以通过表达式的结果（True 或 False）决定要执行的代码块。

1、if

基本语法为：if...elif...else，elif 可以有多个，并且 if 可以进行嵌套。

gender = int(input("请输入数字："))
if gender == 0:
    print("男")
elif gender == 1:
    print("女")
else:
    print("未知")

2、match...case

# python 3.10及以后版本支持
# case _ 表示匹配所有
match gender:
    case 1:
        print("男生")
    case 2:
        print("女生")
    case _:
        print("未知")

五、循环语句

Python 中的循环语句有 for 和 while。

1、for循环

for 循环语法结构如下：

for 变量名 in 序列:
    循环体语句

使用 for 循环遍历一个列表

# for 循环
sites = ["baidu", "google", "taobao", "ali"]
for site in sites:
    print(site)

2、while循环

while 循环语法结构如下

while 判断条件：
    执行语句……

我们测试一下

# while 循环
a = 1
while a != 0:
    num = int(input("请输入数字："))
    print(num)
    if num == 0:
        a = 0
else:
    print("退出代码："+str(a))

3、break 和 continue 语句

• break：表示跳出整个循环
• continue：表示跳出当前循环，执行下一次循环

# for 循环
sites = ["baidu", "google", "taobao", "ali"]
for site in sites:
    if site.__eq__("baidu"):
        # 等于 baidu 时退出本次循环，执行下一次
        continue
		
    print(site)
	
    if site.__eq__("taobao"):
        # 等于 taibao 时，直接退出循环
        break

六、推导式

# 列表推导式
names = ["zhangsan", "lisi", "wnagwu", "zhaoliu"]
# 将列表中名称长度大于4的数据存储到新的列表中
new_names = [name.upper() for name in names if len(name) > 4]
print(new_names)

# 字典推导式
# 使用列表中字符串作为键,加上值创建一个字典
new_dict = {key: 18 for key in new_names}
print(new_dict)

# 集合推导式
# 判断不是abcd的字母并输出
a = {x for x in 'abcdefcasdfzbcd' if x not in 'abcd'}
print(a)

# 元组推导式
# 元组推导式和列表推导式的用法也完全相同，只是元组推导式是用 () 圆括号将各部分括起来，而列表推导式用的是中括号 []
# 并且元组推导式返回的结果是一个生成器对象 generator 类型。
b = (x for x in range(1, 10) if x % 2 == 0)
print(tuple(b))

七、函数

函数能提高应用的模块性，和代码的重复利用率。Python提供了许多内建函数，比如print()。也可以自己自定义函数。

1、函数定义与调用

自定义函数语法结构如下：

def 函数名（参数列表）:
    函数体

定义一个函数并调用

# 计算两数之和
def sum_num(a, b):
    return a + b

# 调用函数
print(sum_num(2, 2))

2、参数类型

python 中参数分为下面几种类型：

• 必需参数
  必需参数表示必须得以正确的顺序传入函数。并且调用时的数量必须和声明时的一样。

def print_str(name):
    print(name)

# 调用时必须传入参数，否者报错：TypeError: print_str() missing 1 required positional argument: 'name'
print_str()

• 关键字参数
  关键字参数表示我们可以在调用时，直接通过对应的参数名称来传递参数，可以不按照方法定义的参数顺序来传递。

def printinfo(name, age):
    print ("名字: ", name)
    print ("年龄: ", age)


#调用printinfo函数
printinfo(age=50, name="Snow")

• 默认参数
  如果我们定义了默认参数，当此参数没有传递时，就会使用默认的参数值。

def printinfo(name, age=18):
    print("名字: ", name)
    print("年龄: ", age)


#调用printinfo函数
printinfo(name="Snow")

• 不定长参数
  跟我们 java 中的可变参数类型，使用 * 可以接受我们传递的多个参数。
  一个星号表示传递的参数使用元组接受，两个星号表示传递的多个参数使用字典接受

def printinfo(arg1, *vartuple):
    print(arg1)
    for var in vartuple:
        print(var)


# 调用printinfo 函数,可以只传递第一个参数，也可以传递多个参数
printinfo(10)
printinfo(70, 60, 50)

def printinfo( arg1, **vardict ):
    print ("输出: ")
    print (arg1)
    print (vardict)

# 结果为:
# 1
# {'a': 2, 'b': 3}
printinfo(1, a=2,b=3)

3、参数传递

与 java 中的值传递和引用传递类似。

当我们函数方法中的参数为不可变类型时，并不会修改传进去的参数的值。而当我们使用 可变类型时，可以修改传递进来的值。

我们可以通过下面两个例子来理解一下；

# 不可变类型如：整数、字符串、元组
def param_change(a):
    print(id(a))
    a = 10
    print(id(a))

# 调用结果如下，可以看出最后修改后的a的地址不是我们原始传递进去的a：
# 140703324431144
# 140703324431144
# 140703324431432
a = 1
print(id(a))
param_change(a)


# 可变类型如：列表、集合、字典等
def changeme(my_list):
    my_list[0] = 11


# 调用结果如下，可以看出方法执行后地址还是同一个，但是值改变了：
# [33, 44, 55, 66] 2732550542720
# [11, 44, 55, 66] 2732550542720
my_list = [33, 44, 55, 66]
print(my_list, id(my_list))
changeme(my_list)
print(my_list, id(my_list))

4、匿名函数

匿名函数使用 lambda 来实现,lambda 只是一个表达式，函数体比 def 简单很多。

基本语法结构如下：
lambda [arg1 [,arg2,.....argn]]:expression

使用匿名函数实现两数相加

lambda_sum = lambda a, b: a + b
print(lambda_sum(1,2))

八、文件操作

1、open 方法

python 中使用 open() 方法打开一个文件，并返回一个文件对象。

• 基本语法结构如下：

open(filename, mode)

• 完整的语法格式为：

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

• 参数：
  filename：访问文件的路径名称。
  mode：打开文件的模式：只读，写入，追加等。
  buffering: 设置缓冲
  encoding: 一般使用utf8
  errors: 报错级别
  newline: 区分换行符
  closefd: 传入的file参数类型
  opener: 设置自定义开启器，开启器的返回值必须是一个打开的文件描述符。

mode 可选值如下图：

下面是一个简单读写文件例子：

注意：使用完成后一定不要忘记关闭这个文件。

# 打开一个文件，可以通过 mode 参数设置是否可以读写、覆盖等操作
file1 = open("D:/Snow/filetest.txt", "w+")

# 判断文件是否可写
if file1.writable():
    print("进行写操作")
    file1.write("你好吗\n")
    file1.write("让自己开心一点\n")
    # 将文件指针定位到文件开头,然后读取文件
    file1.seek(0)
    print(file1.read())
else:
    print("不可进行写操作")

# 也可使用 r 类型的 mode 进行读操作
file2 = open("D:/Snow/filetest.txt", "r+")
str1 = file2.readline()
print(str1)
file2.close()

下面的写法会自动关闭文件对象

with open("file.txt", "r") as file:
    content = file.read()
    # 在代码块中进行文件读取和其他操作

# 在这个位置，文件已经自动关闭

2、常用方法

下面介绍一些 file 对象的常用方法

方法名	描述
file.close()	关闭文件。关闭后文件不能再进行读写操作。
file.flush()	刷新文件内部缓冲，将内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
file.read(size)	读取文件内容,size 是一个可选的数字类型的参数。 当 size 为空或者为负, 读取所有内容
file.readline()	读取文件内容的一行
file.write(str)	将字符写入到文件中，返回写入的字符数
file.writable()	判断文件是否可以写入
file.tell()	返回当前位置前的所有字节数
file.seek()	改变文件指针位置，0 表示开头, 1 表示当前位置, 2 表示文件的结尾

九、面向对象

我们可以看一个简单的类

class MyClass:
    name = 'snow'
    age = 24

    def my_info(self):
        print("姓名："+self.name + "，年龄：{}".format(self.age))


me = MyClass()
me.my_info()

类

Python中的类提供了面向对象编程的所有基本功能：类的继承机制允许多个基类，派生类可以覆盖基类中的任何方法，方法中可以调用基类中的同名方法。

类中有很多 Python 内置的方法，前后都有两个下划线，如：__init__，初始化构造函数

对象

当我们创建一个类的实例时，我们称之为对象或实例。上面例子中的 me 就是一个对象。

属性

类中定义的变量称为属性，python 中可以不需要实例化，直接通过类名来调用属性。

使用一个或两个下划线开头，表示声明该属性为私有，不能在类的外部被使用或直接访问。

如：__name

方法

python中的方法使用 def 关键字来定义，方法必须使用类对象来调用。

方法与属性一致，也可以使用一个或两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类的外部调用。