0基础学Python-Python基础

一、Python 基础

1.python中的数据类型

# 1、数值类型=> (整数类型与浮点数类型)
a =10
print(type(a))
输出： <class 'int'>

b = 9.88
print(type(b))
输出： <class 'float'>

# 2、布尔类型
c = True
d = False
print(type(c))
输出： <class 'bool'>

#3、字符串类型
e ='hello world '
print(type(e))
输出： <class 'str'>

# 4、列表类型
f =[1, 2, 3]
print(type(f))
输出： <class 'list'>

# 5、元组
g=(1,2,3)
print(type(g))
输出： <class 'tuple'>

# 6.字典
h = {'name': '张三'}
print(type(h))
输出： <class 'dict'>

# 6.集合
r = {"1","2","3"}
print(type(r))
输出： <class 'set'>

2.BUG

程序运行过程中出现的错误，需要进行排查，及时纠正错误。

解决方式分三步：

• 查文件=> File "E:\HM_DSJ\DEMO\ex1.py"
• 查行号=> line 3
• 错误描述（错误类型：错误详细信息）=> NameError: name 'names' is not defined 

万能方法：CTRL+C => 度娘 => CTRL+V

2.1 调试工具Debug

Debug工具是PyCharm IDE中集成的专门用来调试程序的工具，在这里程序员可以查看程序的执行细节和流程,以方便我们快速找出程序的Bug! 
Debug工具使用二步走:①打断点②Debug调试

对于简单的代码我们可以直按在第一行添加一 个断点;
对于复杂的程序，有逻辑关键如 if/while/for 等等，断点必须添加到关键字的前面

程序只运行到断点处，点击 step over 执行下一行代码。

3.python 格式化输出

3.1 格式化输出

目前为止,我们所有的输出都是直接通过print(变量名称)形式直接打印的。但是实际工作中，我们可
能需要对变量的输出进行格式化操作(按照定格式进行输出)。

3.2 百分号%格式化输出

语法：

print( '变量名称' )
print('字符串%格式' % ('变量名称'))

print('字符串%格式%格式%格式' % ('变量名称1','变量名称2','变量名称3'))

name = '张三'
age = 11
print('我叫%s，今年%d岁了' % (name, age))

# 输出：我叫张三，今年11岁了

注意:前面有多少个%百分号，后面就应该有多少个变量，而且顺序不能颠倒

%常见格式如下：

 如果需要在百分号形式的格式化输出中，在输出一个百分号，我们可以通过%%来实现!

# 案例:由于受到俄罗斯与乌克兰战争影响，原油价格上5% !
num=5
print('由于受到我岁斯与乌克兰战争影响，原油价格上浮%d%%! ' % num)

输出：由于受到我岁斯与乌克兰战争影响，原油价格上浮5%! 

3.3 format方法格式化输出（推荐）

print('字符串{}’. format(变量名称1))
print('{}字符串{} . format(变量名称1，变量名称2)

案例：

name = '张三'
age = 13
print('我叫{}，今年{}岁了'.format(name,age))

输出：我叫张三，今年13岁了

 在Python3.6以后版本，为了简化format输出操作,引入了一个简写形式:

name = '大白菜'
price = 13.5222
print(f'蔬菜降价了{name}，今天{price:.2f}元/斤')

输出：蔬菜降价了大白菜，今天13.52元/斤

{price:.2f} => 保留两位小数

3.4 格式化输出的转义符号

在字符串中，如果出现了t和n,其代表的含义就是两个转义字符

\t :制表符， 一个tab键(4个空格)的距离
\n :换行符

 案例:

print(' *\t*\t*' )
print('hello\nworld' )

输出：
*	*	*
hello
world

特别说明:默认情况下， 每个print()方法执行完毕后， 都会输出一个\n换行符。如果不想让print()方
法换行，可以添加一个end参数

print("*",end='')

 4. Python中的标准输入

基本语法

input()

但是往往只有input(方法，意义不大,我们还应该使用一个变量来临时接受用户的输入，已方便后
期的操作。

input("提示信息")

案例：

name = input('请输入账号：')
print('账号为：', name)

结果：
请输入账号：124 （手动输入）
账号为： 124

5.python 的标准运算符

5.1 数据类型转换

案例：

id = input(' 请输入您购买商品的编号: ')
name = input( '请输入您购买商品的名称: ')
price = input(' 请输入您购买商品的价格: '))

# 2、使用print()方法进行格式化输出
print(f'您购买了{name}，商品编号为{id},商品价格为{price * 2}, 欢迎下次光临! ')

由于 input 输入的数据类型为字符串（str）因此需要转换为浮点类型（int）才能进行计算：

price = float(input(' 请输入您购买商品的价格: ')) #转换为浮点型

5.2 运算符的使用

5.2.1 算数运算符

 案例：

a = float(input('请输入上底'))
b = float(input('请输入下底'))
h = float(input('请输入高'))

# 面积公式 
s = (a + b) * h / 2
print(f'梯形的面积为{s:.2f}')

结果：
请输入上底2
请输入下底3
请输入高5
梯形的面积为12.5

 5.2.2 赋值运算符

5.2.3 复合赋值运算符

复合赋值运算符的计算顺序=先执行算术运算符，执行完毕后，把结果在赋值给左边的变量。 

案例：

i = 1
i += 1  # i= i+1

print(i)  # 2

 5.2.3 比较运算符

5.2.4 逻辑运算符 

5.2.5 短路运算符

在Python代码中，逻辑运算符的运算,要遵循短路运算原则。
①表达式1and表达式2，如果表达式1条件为真,则最终的运算结果由右边的表达式2来决定。如果表达式1条件为假，则最终结果为假。其右边的表达式2不需要在进行运算。

②表达式1or表达式2，如果表达式1为真,则最终的运算结果由表达式1来决定,为真。如果表达式1为假，则最终结果由表达式2来决定。如果表达式2为真，则最终结果为真,如果表达式2为假，则最终结果为假。

print(3 and 4 and 5)
print(5 and 6 or 7)
4 > 3 and print('hello world' )

5.2.6 算数符的优先级

6.python 分支语句

6.1 if 选择结构

a = int (input('输入年龄'))
if a >= 18 :
    print('已成年')
else: print('未成年')

结构如下：

if elif else 结构

if 条件判断1:
        如果此条件为True，则执行这个语句段elif 条件判断2:
elif 条件判断2:

        如果此条件为True，则执行这个语句段
else :
        如果以上所有条件判断都不满足时，则执行这个语句段 

案例：

a = int (input('输入年龄'))
if a > 18 :
    print('已成年')
elif a == 18:
    print('刚刚成年')    
else: print('未成年')

6.2 if 嵌套

 if 外层条件判断:
        #如果条件为True，则执行以下语句段if 内层条件判断: 

        if 内层条件判断
                #如果内层条件为True，则执行以下语句段
else:
        如果条件为False，则执行以下语句段

a = int (input('输入年龄'))
if a > 18 :
    if a < 60:
        print('xxxxx')
elif a == 18:
    print('刚刚成年')
else: print('未成年')

6.3 案例：石头剪刀布

玩家:player(玩家手工输入石头0、剪刀1、布2)
(随机出拳)电脑:computer
输赢结果很重要，有三种情况

random 随机结果

random.randint(0, 2) 产生一个0-2的随机数

import random
# 用户输入
user = int(input('输入0-石头，1-剪刀，2-布'：))
# 电脑随机分配
comput = random.randint(0, 2)

if user == comput:
    print(f'{user}{comput}平局')
elif  (user==0 and comput ==1) or (user==1 and comput ==2) or(user==2 and comput ==3) :
    print(f'{user}{comput}玩家胜')
else:
    print(f'{user}{comput}电脑胜')

结果：
输入0-石头，1-剪刀，2-布： 1
12玩家胜

6.4 三目运算符

在Python中三目运算符也叫三元运算符，其主要作用就是用于简化if..else...语句。

if 条什判断:
        # 语句段1
else:                                =>         语句段1 if 条件判断 else 语句段2
        # 语句段2                        

a = 10
b = 20

c = 10 if a>b else 2 # 如果 a>b 则返回10 否则 返回2
print(c)

结果： 2

 7. python 的循环结构

7.1 while 循环

while 循环三步走:
①定义一个计数器，一般为i=日或者i =1

②编写循环条件，如while i<= 100:

③在循环体内部(有缩进)更新计数器的值

i=1 
while i< 100:
    print('666') #输出99次
    i+=1 #每次循环累加1

 7.2 循环关键词

break和continue

break和continue是循环中满足一定条件退出循环的两种不同方式

举例:一共吃5个苹果，吃完第一个，吃第二个…，这里"吃苹果”的动作是不是重复执行?
情况一:如果吃的过程中，吃完第三个吃饱了，则不需要再吃第4个和第5个苹果，即是吃苹果的动作停止，这里就是break控制循环流程，即终止此循环。

情况二:如果吃的过程中，吃到第三个吃出一个大虫子.…,是不是这个苹果就不吃了，开始吃第四个苹果，这里就是continue控制循环流程，即退出当前一次循环继而执行下一次循环代码, 

• break 用于完全退出循环，不再执行循环内的后续语句。
• continue 用于跳过当前迭代的剩余语句，直接进行下一次迭代。

7.3 for循环

基本语法:
for 临时发量 in 数据容器:

        print(临时变量)

执行原理:
①)首先判断数据容器中有多少个元素，则for循环就要循环多少次
② 每次循环时，系统会自动将遍历得到的字符放入临时变量(临时变量一般起名叫做i)中，打印这个变量就相当于输出字符串中的每一个字符

案例1：遍历

a = 'adafgjjkk'
for i in  a:
    print(i)

输出：
a
d
a
f
g
j
j
k
k

案例2：循环

for i in  range(1,5): # range(1,5) => 1-5这各数字区间
    print(i)

输出：
1
2
3
4

8.字符串的操作

8.1 字符串的切片

8.2 字符串的操作方法

所谓字符串查找方法即是查找子串在字符串中的位置或出现的次数。
基本语法:

字符串. find(要查找的字符或者子串)

 作用:检测某个子串是否包含在这个字符串中，如果在返回这个子串开始的位置下标，否则则返回-1。

#定义一个字符串
str1 ='hello world hello linux hello python'
# 查找linux子串是否出现在字符串中
print(str1.find('linux'))
#在str1中查找不存在的子串
print(str1.find('and'))

结果：
18
-1

8.3 字符串的修改

9.数据容器 

在Python中，有多种内置的数据容器类型，每种类型都适用于不同的数据存储和操作需求。以下是Python中常用的数据容器类型：

列表 (list):

# 例子 my_list = [1, 2, 3, 'a', 'b', 'c']

• 列表是一种有序、可变的数据集合。
• 使用方括号 [] 定义，可以包含任意类型的数据，甚至可以是不同类型的混合数据。
• 支持增删改查操作，是最常用的序列类型之一。

• 增加元素：

  • 使用 append() 方法在列表末尾添加元素。
  • 使用 insert() 方法在指定位置插入元素。
  my_list = [1, 2, 3] my_list.append(4) # [1, 2, 3, 4] my_list.insert(1, 'a') # [1, 'a', 2, 3, 4]

• 删除元素：

  • 使用 remove() 方法删除指定值的元素。
  • 使用 pop() 方法删除指定位置的元素，并返回该元素。
  my_list = [1, 'a', 2, 3, 4] my_list.remove('a') # [1, 2, 3, 4] popped_value = my_list.pop(2) # my_list becomes [1, 2, 4]; popped_value is 3

• 修改元素：

  • 直接通过索引赋值来修改列表中的元素。
  my_list = [1, 2, 3] my_list[1] = 'b' # [1, 'b', 3]

• 查找元素：

  • 使用 index() 方法查找指定值的索引。
  • 使用 in 关键字来检查某个元素是否在列表中。

  my_list = [1, 'b', 3] idx = my_list.index('b') # idx will be 1 is_present = 'a' in my_list # is_present will be False

元组 (tuple):

# 例子 my_tuple = (1, 'apple', 3.14)

• 元组是一种有序、不可变的数据集合。
• 使用圆括号 () 定义，一旦创建，元素不可修改。
• 通常用于存储异质数据，或作为函数返回值等不希望被修改的数据结构。

        

由于元组是不可变的，它只支持查找操作，而不支持增加、删除和修改操作。

• 查找元素：

  • 使用 index() 方法查找指定值的索引。
  • 使用 in 关键字来检查某个元素是否在元组中。

集合 (set):

• 集合是一种无序、可变的数据集合，里面的元素不重复。
• 使用大括号 {} 定义，可以进行并集、交集、差集等集合操作。
• 用于去除重复项或进行集合运算。

# 例子 my_set = {1, 2, 3, 3, 4} # 输出: {1, 2, 3, 4}

• 增加元素：

  • 使用 add() 方法添加单个元素。
  • 使用 update() 方法添加多个元素（可以是列表、元组等）。
  my_set = {1, 2, 3} my_set.add(4) # {1, 2, 3, 4} my_set.update([4, 5]) # {1, 2, 3, 4, 5}

• 删除元素：

  • 使用 remove() 方法删除指定元素，如果元素不存在会抛出 KeyError。
  • 使用 discard() 方法删除指定元素，如果元素不存在不会抛出异常。
  • 使用 pop() 方法随机删除一个元素。
  my_set = {1, 2, 3, 4, 5} my_set.remove(3)

• 查找元素：

  • 使用 in 关键字来检查某个元素是否在集合中。
  my_set = {1, 2, 3} is_present = 2 in my_set # is_present will be True

1. 字典 (dict):

   # 例子 my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}
   • 字典是一种无序的键值对集合，可以通过键来快速查找值。
   • 使用大括号 {} 定义，每个键值对用冒号 : 分隔，键值对之间用逗号 , 分隔。
   • 用于存储具有映射关系的数据。

• 增加或修改元素：

  • 直接通过键来设置或修改值。
  my_dict = {'name': 'Alice', 'age': 25} my_dict['city'] = 'New York' # {'name': 'Alice', 'age': 25, 'city': 'New York'} my_dict['age'] = 26 # {'name': 'Alice', 'age': 26, 'city': 'New York'}

• 删除元素：

  • 使用 del 关键字删除指定键的键值对。
  • 使用 pop() 方法删除指定键的键值对，并返回对应的值。
  my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'} del my_dict['age'] # {'name': 'Alice', 'city': 'New York'} popped_value = my_dict.pop('city') # my_dict becomes {'name': 'Alice'}; popped_value is 'New York'

• 查找元素：

  • 使用键来访问对应的值。
  my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'} age = my_dict['age'] # age will be 25

10.函数

陈序中有很多类似的功能，封装成函数实现代码的复用

 函数的定义

def 函数名(参数):

        函数体

        return 结果

函数的调用

函数名(参数)

案例：

def addition(a, b):
    sum = a + b
    return sum

print(addition(1,2)) #输出3

10.1函数的嵌套

所谓函数嵌套调用指的是一个函数里面又调用了另外一个函类

def testA():

        print('这里是A')

def testB():

      print('这里是B')

      testA()

案例：

def testB():
    print('这里是B')

def testA():
    print('这里是A')
#     调用另外一个函数
    testB()
# 调用A函数
testA() #这里是A
        #这里是B

10.2案例：面试题

案例1:编写个函数，有个参数str1，输入信息如“1.2.3.4.5’，使用函数对其进行处理、要求最终的返回结果为'5-4-3-2-1'

# 定义一个函数
def func(str1): #str = '1.2.3.4.5'
    a=str1[::-1] #翻转 [5.4.3.2.1]
    return a.replace('.','-') #将.替换为-

print(func('1.2.3.4.5'))

结果：5-4-3-2-1

案例2:使用函数生成4位长度的验证码

import random
# 定义一个函数
def func():
    # 定义一个字符串，用于生成眼真没
    str1 = '123456789zxcvbnmasdfghjkpuytrewqZXCVBNMMLKJHGFDSAQWERTYUP'
    code = ''
    for i in range(4):
        ran = random.randint(0,len(str1)-1)
        code += str1[ran]
    return code
print(func())

10.3变量的作用域

变量作用域指的是变量的作用范围(变量在哪里可用，在哪里不可用)，主要分为两类:

局部变量和全局变量

10.3.1 局部变量和全局变量

所谓局部变量是定义在函数体内部的变量，即只在函数体内部生效。

a = 1                              #全局

def testA():

        a=100print(a)        #局部

testA()#100

print(a)# 报错:name 'a' is not defined

10.3.2 global

从当前行开始，以后使用的同名变量就是全局变量!

语法：

global 局部变量

在局部作用域中我们可以实现对全局变量的"访问"，但是不能实现对全局变量的修改与删除等操作,

a=100
def ex():
    global a #修改为全局
    a= 1
ex()
print(a) #输出1

 10.4函数的参数

在函数定义与调用时，我们可以根据自己的需求来实现参数的传递，在Python中，函数的参数一共有两种形式:① 形参 ② 实参
形参:在函数定义时，所编写的参数就称之为形式参数
实参:在函数调用时，所传递的参数就称之为实际参数

def greet(name):         # name就是在函数greet定义时，所编写的参数(形参)

        return name +'，您好

# 调用函数
name ='老王
greet(name)        #在函数调用时，所传递的参数就是实际参数

10.4.1 函数参数类型

位置参数

理论上，在函数定义时，我们可以为其定义多个参数。但是在函数调用时，我们也应该传递多个参数，正常情况，其要一一对应。

def user_info(name, age, address):
        print(f'我的名字{name}，今年{age}岁了，家里住在{address}')
# 调用函数
user_info('Tom'，23，'美国纽约')

关键词参数

函数调用，通过“键=值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。

def user_info(name, age,address):
        print(f'我的名字{name}，今年{age}岁了，家里住在{address}')

# 调用函数(使用关键词参数)
user info(name='Tom'.age=23，address='美国纽约')

11.文件操作

文件操作三步走
1、打开文件
2、读写文件
3、关闭文件

11.1 open 打开文件

在Python，使用open()函数，可以打开一个已经存在的文件，或者创建一个新文件，

语法如下
f = open(name, mode,encoding)

注;返回的结果是一个file义件对象(后续会学习，只需要记住，后续都是f.方法())
 

name:是要打开的目标文件名的字符串(可以包含文件所在的具体路径)。
mode:设置打开文件的模式(访问模式):只读r、写入w、追加a等。

encoding:设置编码

 r:read，只读模式，代表只能对文件进行读取，属于默认模式，如果要访问的文件不存在，则直接报错!w:write;只写模式，代表只能对文件进行写入操作，如果访问的文件不存在，则系统会自动创建，但是写入文件时它首先要把文件内容清公、然后再写入新内容。

a : append，追加模式(只写模式的 种):与v类似，如果访间的文件不存在，也可以自动创建该文件但是在写入数据到文科时，其并不会清空文件的原有内容。注意:open力法操作完成后，返回的是一个义什对象(对象的概念后面会学，也可以叫做义什句)以后的读写都需要依赖这个对象(句柄)

 案例：

# 打开文件
f = open('./text.txt','w',encoding='UTF-8')
# 写入数据
f.write('ssss')
# 关闭文件
f.close()

11.2 文件的备份 

oldname = input('请输入您要备份的文件名称:')
# oldname ='test.txt'，拆解文件名与文件的后缀
index = oldname.rfind('.')
# 获取文件名称
filename = oldname[:index]  # test
postfix = oldname[index:]  # .txt
# 拼接新文件名称
newname = filename + '[备份]' + postfix
print(newname)

old_f = open(oldname,'rb')
new_f = open(newname,'wb')
while True:
    content = old_f.read(1024)
    if not content:
        break
    new_f.write(content)# 操作完成后，关闭文件
old_f.close()
new_f.close()

11.3 文件文件夹操作

11.3.1 OS模块

11.4 文件夹的删除

#导入shuti1模块
import shutil

# 递归删除非空目录
shuti1.ritree('要删除文件夹路径')

递归删除文件夹的原理:

理论上，其在删除过程中，如果文件夹非空，则自动切换到文件夹的内部，然后把其内部的文件，一个一个删除，当所有文件删除完毕后，返回到上一级目录，删除除文件夹本身。

 12. 异常

当检测到一个错误时，解释器就无法继续执行了，反而出现了一些错误的提示，这就是所谓的"异常"。
特别强调:异常并不是错误，有所不同的。异常往往是由于输入信息异常或者未知的结果导致程序无法执行!

 比如：

print(10/0) #除数为0

异常捕获：基本语法

try:
        可能发牛错误的代码
except:
        如果出观异常执行的代码

案例：

num = int(input('输入除数')) #输入 0
sum = 0
try:
    sum = 10/num
except Exception as e:
    # 对于异常的处理
    # e 为报错信息
    print('除数不能为0',e)
# 当try语句中的代码没有出现异常，则执行else语句中的代码，反之，则不执行
else:
    print(sum)

12.1 异常捕获中的finally语句

finally:

        适合实现一些收尾的工作，因为它是无论是否异常都会执行的代码

示例：

num = int(input('输入除数')) #输入 0
sum = 0
try:
    sum = 10/num
except Exception as e:
    # 对于异常的处理
    # e 为报错信息
    print('除数不能为0',e)
# 当try语句中的代码没有出现异常，则执行else语句中的代码，反之，则不执行
else:
    print(sum)
# 特别适合实现一些收尾的工作，因为它是无论是否异常都会执行的代码
finally:
    print('程序结束')
    
输出：
    输入除数0
    除数不能为0 division by zero
    程序结束

13. python中的内置模块

14.综合案例：学生管理系统 

附上源码：

# 保存学生信息列表
students = [
    {'name':'张三','age':'19','mobile':'19189204'}
]  # 采用json格式=> [ {} , {}]

# 添加信息方法
def  add_student():
    # 暂存学生信息
    student = {}
    student['name'] = input('请输入需要添加学生的姓名：')
    student['age'] = input('请输入需要添加学生的年龄：')
    student['mobile'] = input('请输入需要添加学生的电话：')
    # 把这个字典追加到全局的students列表中
    students.append(student)
    print('信息添加成功')
    print(students)

# 删除信息
def del_student():
    del_name = input('请输入需要删除的学生')
    for i in students:
        if i['name']==del_name: #相等就代表找到了这个同学
            students.remove(i)
            print(f'{del_name}同学已删除！')
            break
    else:
        print('未找到该同学信息')

def set_student():
    name = input('请输入需要修改的学生')
    for i in students:
        if i['name']==name: #相等就代表找到了这个同学
            set_num = input('请输入需要修改的信息 name/age/mobile')
            if set_num in ('name','age','mobile'):
                if set_num == 'name':
                    i['name'] = input('请输入需要修改后的name')
                    print('修改成功')
                    break
                elif set_num == 'age':
                    i['age'] = input('请输入需要修改后的age')
                    print('修改成功')
                    break
                elif set_num == 'mobile':
                    i['mobile'] = input('请输入需要修改后的age')
                    print('修改成功')
                    break
            else: print('输入错误')
        else:print('未找到该学生')

def select_student():
    name = input('请输入需要查询的学生')
    for i in students:
        if i['name']==name: #相等就代表找到了这个同学
            print(i)
            break
        else:
            print('未找到该同学信息')

def  all_student():
    for i in students:
        print(i)

# 封装菜单函数
def menu():
    print('-' * 40)
    print('欢迎使用学生管理系统V1.0')
    print('【1】添加学员信息')
    print('【2】删除学员信息')
    print('【3】修改学员信息')
    print('【4】查询学员信息')
    print('【5】遍历所有学员信息')
    print('【6】退出系统')
    print('-' * 40)

# 死循环
while True:
    menu()
    # 输入执行编号
    user_sum = int(input('请输入执行功能编号'))
    if user_sum in (1, 2, 3, 4, 5, 6):
        if user_sum == 1:
            add_student()
        if user_sum == 2:
            del_student()
        if user_sum == 3:
            set_student()
        if user_sum == 4:
            select_student()
        if user_sum == 5:
            all_student()
        elif user_sum == 6:
            print('已退出系统')
            break
    else:
        print('输入有误请重新输入')
        continue