Python编程 I 基础

Python编程 I

变量

1
2
	print("hello world")
# 函数("传入参数")

变量的命名

我们可以设置一个变量名再将其打印 ：

1
2
message = "hello world"
print(message)

命名要求和风格

变量名接受的字符 ： 大小写字母，数字，下划线。数字不能在首位出现

风格：

大驼峰式(常用于类定义，函数定义) ： ThisIsAVariableDefine

小驼峰式(常用于类定义，函数定义) ： thisIsAVariableDefin

下划线风格(常用于变量声明) : my_variable

变量名尽可能起得容易理解。

变量是什么

在我们的最初讨论中，变量是一个通过映射与实际对象建立关系的标识符。

当然目前可以理解为一个标签用来寻找我们真正想处理的内容

字符串

字符串是一种python的数据类型

直接就可以定义

1
2
3
4
str1 = "string"
str1.upper()  # 将字符串转换为全部大写，输出 ： STRING
str1.lower()  # 将字符串转换为全部小写，输出 ： string
str1.title()  # 将字符串转换为首字母大写，输出 ：String

格式化输出

python 提供多种字符串的输出方式

同时可以使用’\char’ 来在字符串中添加转义字符

\t 制表符

\n 换行

1
2
3
4
5
6
7
8
9
10
11
12
13
StringA = "a"
StringB = "b"
StringC = "c"
StringD = "d"
print("hello %s" % StringA)
print("hello "+StringB)
print(f"hello {StringC}")
print("hello {}".format(StringD))
# 输出 ：
# hello a
# hello b
# hello c
# hello d

数值

整数

python支持数学运算

1
2
3
4
5
6
7
8
a,b,c,d = 1,2,3,4 
print(a+b)      # 加法 输出 3
print(a-b)      # 减法 输出 -1
print(b*c)      # 乘法 输出 6
print(c/d)      # 除法 输出3/4
print(d//4)     # 整除  输出1
print(d%c)      # 取余数 输出1
print(d**b)     # 计算平方 输出 16

浮点数

同样支持数学运算，在有浮点数参与的计算种会被自动转化为浮点数

常量

Python 中通常用大写来标记一个量为常量：

1
MAX_VALUE = 5000

注释

python 使用两种风格的注释 单行注释 # 和 多行注释 “”” … “””

1
2
3
# 单行注释
""" 多行
注释 """

列表

列表是一种能够容纳多个元素的数据结构

1
2
lst1 = list()  #显式创建空列表
lst2 = []      #隐式创建空列表

python中的列表不会限制列表中元素的类型，也不会限制整个列表的长度

一些通用函数

1
2
3
4
5
6
7
8
9
lst1 = list()
lst2 = [2,5,8,9,7,6,2,3,9]
 
lst1.append(1)                 # 向列表中添加元素              [1]
lst1.append("hi")              # 添加其他类型的元素            [1, 'hi']
lst1.remove(1)                 # 删除列表中的元素              ['hi']
lst1.extend(lst2)              # 将lst2中的元素添加到lst1      ['hi', 2, 5, 8, 9, 7, 6, 2, 3, 9]
lst1.reverse()                 # 反转列表                      [9, 3, 2, 6, 7, 9, 8, 5, 2, 'hi']
lst1.pop()                     # 弹出末尾元素赋值给变量         [9, 3, 2, 6, 7, 9, 8, 5, 2]

列表操作

遍历

对于想读取列表中的每个元素，可以使用for in 来进行读取：

1
2
3
4
5
6
7
8
9
for i in lst2 :       # i作为临时变量使用用来获取lst2中的元素
    print(i,end=",")      # end=  设置输出的结束符
# 输出 2,5,8,9,7,6,2,3,9,

for i in range(0,len(lst2)):  # 也可以使用range来完成循环，每次执行会将i增加1
    print(lst2[i],end=",")
# 输出 2,5,8,9,7,6,2,3,9,
# range的范围是前闭后开
range 还可以按步长输出

列表生成式

当需要创建类似 [1,2,3,4,5,6,7,8,9]的列表时，可以直接通过for循环创建

1
2
lst3 = [i for i in range (0,10)] 
# 创建列表 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

切片

如果想获取列表中的部分元素可以通过下标对某位置的元素进行获取 

1
2
3
lst3[0]    # 获取第一个元素 即0
lst3[2:5]  # 获取第3-5个元素的子列表
lst3[::-1] # 获取反转列表

复制列表

有些情况下需要对列表进行复制操作，这时需要考虑是否会对源列表有影响

1
2
3
4
5
lst0 = [1,2,3]                   #定义了一个列表的数据结构
lst4 = [1,2,3,4,5,6,7,lst0]      #添加到另一个列表中
lst5 = lst4[::]                  #复制列表lst4到lst5
lst5[-1][0] = 2                  #修改5中的lst0
print(lst0)                      # 输出[2,2,3] 发现lst0也被改动了。

这是因为python中 复制列表时，传递过去的都是变量的值，但是对于引用变量（可以理解为包含多个元素的变量，如列表），返回的是该变量的存储位置。所以当修改该变量中的值的时候，还是对原对象进行了修改。所以在复制列表等引用数据类型的时候需要:

1
2
3
4
5
lst0 = [1,2,3]
lst4 = [1,2,3,4,5,6,7,lst0]
lst6 = copy.deepcopy(lst4)        #遍历元素，判断存在引用类型的元素，创建新引用元素加入列表
lst6[-1][0]=2
print(lst0)

元组

在python中，元组是对于一组不可变数据的类型称呼，被定义的元组在后续的使用中不可以被修改

这种设计是对应一些数据的只读属性，防止后期被篡改

1
2
3
tuple1 = （1,2,3）           #使用圆括号定义元组
tuple2 = 1,2,3               #隐式定义元组
tuple3 = 1,                  #或者使用,定义只有一个元素的元组

元组也支持前述中列表的遍历，切片操作。只是不能修改其中的数据，这是由解释器控制的

判断表达式

1
2
3
4
5
6
7
a ='c'
if a == 'a' :                            # 判断条件1
		print("%s is here" % a)
elif a == 'b'  :                      # 判断条件2 可以跟多个else if + 判断条件
    print(f"{a} is here")
else :                                   # 其他情况
    print("{} is here".format(a))

判断条件

1
2
3
4
5
6
7
8
9
!= 不等于
== 等于
is 用于引用变量判断是否是同一个对象
is not 用于引用变量判断是否非同一个对象
in 判断某元素是否中是否包含该元素
not in 判断某元素是否不含有某元素
True  值为真
False 值为假

多条件处理

1
2
3
and  "且" 拼接多个条件判断
or   "或" 拼接多个条件判断

字典

字典是一种键值对的结构 通过对应的键可以进行值的访问。

字典可以接收任意的元素作为键和值，但是要保证键的唯一性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
dict1 = dict()                        #显式创建
dict2 = {"sex":"male"}                #隐式创建
dict3 = {"name":"codfish","age":"28"}
dict3.update(dict2)                   #将dict2中的键值对更新到dict3中
dict3["name"]                         #获取键name对应的值
dict3["name"] = "someone"             #设置修改name键对应的值
dict3.get("name","default value")     #获取一个键的值,不存在对应键的时候返回默认值
for i in dict3.keys():                #遍历打印所有的键
    print(i)

for j in dict3.values():              #遍历打印所有的值
    print(j)

for k,v in dict3.items() :            #通过.items 获取键和值
    print(f"your {k} is {v}")

接收输入

python中使用“input” 接收数据，返回的是一个字符串类型

1
2
age = input("input your age")
print(type(age))   # type返回变量的类型， 输出为<class 'str'>

循环

除了使用for 之外，还可以使用while进行循环控制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
counter = 10
while counter > 3 :
	if counter == 6 :
		print("current is %d " % counter)          
	elif counter == 7 :
	  continue                          #跳过本次循环,循环继续
	elif counter == 4 :
		break                             #跳出while循环执行后续工作流
	else :
	  print(counter) 
	  
	输出:
	PS D:\Software> python .\anmial.py
	10
	9
	8
	current is 6 
	5

函数

函数是一段执行特定功能的代码块，当某些功能在多个位置重复使用时，使用函数可以提高代码复用，提升编程效率

1
2
3
4
5
6
#python 中的函数定义
def              say_hello(name):
#函数声明保留字  函数名   参数信息
	 print(f"hello {name}")
	 
say_hello("codfish")  #调用函数 输出 hello codfish

参数

python的 参数支持灵活的定义

1
2
3
4
5
6
def say_hello()    # 无参情况
def say_hello(name)  # 传入一个参数
def say_hello(name,time="evening") # 传入多个参数，且有默认值的参数，有默认值的参数需要位于最后。
def say_hello(name,*args)  # 接收name 和多个参数，返回一个元组arg给函数处理
def say_hello(name,**kwargs)  # 将传入的指定变量名的参数作为一个字典变量kwargs 传入函数处理

形参与实参

形式参数 是用来说明函数功能，作为替代符，使得函数功能的定义完整

实际参数 是真正需要被处理的参数。

在这里 实参同样要注意 值和引用的问题，当传入引用对象的时候，函数 操作的仍然是你的实际对象。

返回值

python 可以接收任意类型的值作为返回值返回给接收它的变量，也可以返回多个值

1
2
3
4
def return_test():                 
    return 1,2,3,4,5              #也可以接收多个值的返回，本质是元组的映射
a,b,c,d,e = return_test()
print(a)

类

在面向对象编程中，类是用来描述一类具有相同功能或组件的事物的抽象模板，通过在类中定义属性和方法（类中的函数），来完成对事物功能的抽象

1
2
3
4
5
6
7
8
9
class Dog          # 定义类 Dog
		def __init__(self,name,age):        # __init__ 用于为后续创建的狗的实例赋值
				self.name = name         
				self.age = age
		def bark(self):
				print(f"{self.name} is barking")  # 小狗具备的功能
				
		def walk(self):
				print(f"{self.name} is walking")

实例

类作为抽象事务的模板，那么由类创造的实例就是对具体事务在计算机上的抽象，通过对类的调用，我们可以得到该类的实例

1
2
3
dog =  Dog("旺柴","3")   # 创建了一只名叫旺柴的3岁的狗
print(dog.name)          # 打印狗的名字
dog.bark()               # 执行狗叫的方法

文件操作

在python中，使用open/close关键字来进行 文件的操作开闭操作

通过encoding 指定文件的字符集

通过 ‘rwa’ 指定文件的读写模式 r 只读 w只写 a追加 r以字节序读取文件

1
2
3
with open("test.txt",encoding="utf-8") as content :       #打开文件,使用with时 不需要使用close关闭这个作用域结束后会自动关闭文件
    a = content.read()                                    #读取文件内容
    print(type(a))                                        #文件内容默认以字符串类型被读取

异常处理

在程序执行过程中，接收到了不符合预期的参数等一些情况会使得程序产生异常。我们可以通过

try-except-finally 来完成异常的捕捉

1
2
3
4
5
6
try :
    8/0                                     # 触发除数异常
except ZeroDivisionError as e  :            # 将异常接收为一个异常对象，可以进行打印或者返回
		print(e)
finally:
    print("it's done")
Python
#Python
Python编程 I 基础
http://gadoid.io/2025/04/14/Python编程-I/
作者
Codfish
发布于
2025年4月14日
许可协议