Python基础

字面量

被写在代码中的固定值

---

数据类型

• 变量没有数据类型但变量储存的数据有类型
• 查看变量类型 type()

money = 50
print("money的数据类型为",type(money))

分类

字符编码相关

• ord(x) 返回对应字符x的ASCII码
• chr(x) 返回ASCII码为x的字符

数据类型检测

isinstance (x,y)函数查询数据x是否是类型y

tyoe(x) 返回x的数据类型

数字Number

整数int

浮点数float

科学计数法

• 用这种方法表示的数一定是浮点数

aEn

a*10^n次

复数complex

• x+yj(以j结尾表示复数)

布尔bool

字符串String

三种定义方式

• 单引号
• 双引号
• 三引号(支持换行)

'''这里是注释
'''
str = '''
awdsda
awdsdawd
awdasdawd'''
print(str)

引号嵌套

• \' \"转义
• 单双引号嵌套

str = '他说"wadsd"awdasd'
print(str)//他说"wadsd"awdasd

字符串的拼接

• +连接两个字符串变量或字面量

• • 无法和非字符串类型进行拼接

字符串的格式化

一般格式化

"%[m.n]占位符"%(变量)

• m为宽度

• • m比数字本身宽度还小，m不生效
  • m比数字本身宽度大，前面补0

• n为精度

• • n会对小数部分做精度限制并四舍五入

常用占位符

• 字符串：%s
• 整数: %d
• 浮点数: %f

msg = "我是%s的学生，今年是%d年"%("山西传媒学院",2023)
print(msg)//我是山西传媒学院的学生，今年是2023年

快速格式化

f"内容{变量}"

school = '山西传媒学院'
year = '2023'
msg = f"我是{school}的学生，今年是{year}年"//我是山西传媒学院的学生，今年是2023年
print(msg)
print(f"我是{school}的学生，今年是{year}年")//我是山西传媒学院的学生，今年是2023年

字符串切片

str[star:end:step]

• star 开始下标
• end 结束下标（取不到该值）
• step 步长

print("12345"[1:3]) # 23
a = "abcdef"
print(a[2:-1]) # cde
print(a[0:6]) # abcde
str = 'abcde'
str2 = str[0:5:2]
print(str2)# ace

字符串运算符

• 字符串连接（+）和字符串复制（*）在进行运算符操作过程中，会分配新的内存空 间，而不是直接进行修改

+连接字符串

*复制字符串

str = 'abc'
str2 = str+'def'
print('str2=',str2)# str2= abcdef
str3 = str * 3
print('str3=',str3)# str3= abcabcabc
str = 'ads'
print('str3=',str3)# str3= abcabcabc

用 in , not in 判断子串

• a in b b中有a时返回true 否则false
• a not in b b中没有a时返回true 否则false

字符串函数

split()分割为列表

• 默认分割str.split()

• • 含字符串x经 空格、制表符、换行符分隔得到的所有子串

• 指定分隔符分割str.split(a)

• • 传入一个字符，返回原字符串根据传入的字符分割后的列表

• 高级分割str.split(x,s)

• • 用正则表达式x里面的分隔串分割s

count()求子串出现的次数

str = "abcba"
print(str.count("b"))# 2

upper()、lower()大小写

str = "abcba"
str1 = "ABCHD"
print(str.upper())# ABCBA
print(str.lower())# abcba

replace(old,new)替换

• old旧字字符串
• new 新字符串
• 替换全部匹配字符
• 返回一个新字符串，不会修改原字符串

str = 'abcdefgabc'
str2 = str.replace('abc','ABC')
print(str) # abcdefgabc
print(str2) # ABCdefgABC

判断字符串内容

isdigit()判断是否全是数字

islower()判断是否全是小写

isupper()判断是否全是大写

startswith()判断是否以某字串开头

endswith()判断是否以某字符串结尾

str = 'abcdefgabc'
print(str.islower()) #True
print(str.isdigit()) # False
print(str.startswith('abc')) #True
print(str.endswith('abc')) #True
print(str.endswith('abe')) # False

去除空格

• 返回一个新字符串，不修改原字符
• 空白字符值 空格、'\r','\t','\n'

strip()去头尾空白字符('\r','\t','\n')

lstrip()去左边空白字符

rstrip()去右边空白字符

查找子串

find()、rfind()

• find()从头开始找返回下标，rfind()从尾巴开始找，返回下标
• 找不到返回-1

index()、rindex()

• index()从头开始找返回下标，rindex()从尾巴开始找，返回下标
• 找不到引发异常

str = 'abcdefgabc'
print(str.find('abc'))# 0
print(str.rfind('abc'))# 7
print(str.index('abc'))# 0
print(str.rindex('abc'))# 7
print(str.find('abwc'))# -1
print(str.index('abwc'))# 报错

字符串不可修改

str = 'abcde'
str[0] = 'b' # 抛出异常
str = 'ws'
print(str)# ws

---

---

列表list

定义

[元素1，元素2，元素3]

特点

• 有序
• 允许重复
• 可修改

列表元素访问

• 负数为倒序取元素

nums = [1,2,3,4,5,[6,7,8,9,10]]
# 定义空列表
nums2 = []
nums3 = list()
print(nums[0])
print(nums[5][0])
print(nums[-1])
'''
1
6
[6, 7, 8, 9, 10]
'''

列表的切片[start:end:step]

• 返回新的列表，用法和字符串切片相同

列表的增删改

• del list[n] 删除列表list中下标为n的元素
• list += [100,101] 将100,101追加到list列表中
• list.append(200) 添加单个元素到list列表中
• list.pop(x) 删除对应元素

列表元素的指针本质

a = [1,2,3]
b = [a,a,[3,4,5]]
print(b) # [[1, 2, 3], [1, 2, 3], [3, 4, 5]]
a[0] = 2
print(b) # [[2, 2, 3], [2, 2, 3], [3, 4, 5]]

a = [[0]]*2 + [[0]]*2
a[0][0] = 5
print(a) #[[5], [5], [0], [0]]

列表的拷贝

• new_list = old_list.copy()等价于newList = oldList[:] 浅拷贝，只是将每一个元素的指针指向同样的地址

• • 修改原列表中引用数据类型中的数据，新列表中的数据也会变

list = [1,2,3,[4,5]]
list2 = list.copy()
list2 = list[:]
print("list2=",list2) # list2= [1, 2, 3, [4, 5]]
list[0] = 2
print("list=",list) # list= [2, 2, 3, [4, 5]]
print("list2=",list2) # list2= [1, 2, 3, [4, 5]]
list[3][0] = 2
print("list=",list) # list= [2, 2, 3, [2, 5]]
print("list2=",list2) # list2= [1, 2, 3, [2, 5]]
list[3] = [5,6]
print("list=",list) # [2, 2, 3, [5, 6]]
print("list2=",list2) # list2= [1, 2, 3, [2, 5]]

• new_list = copy.deepcopy(old_list) 需要引入copy

• • 开辟新空间，将原列表中所有的数据复制一份

import copy
list = [1,2,3,[4,5]]
list2 = copy.deepcopy(list)
list[0] = 2
list[3][0] = 10
print(list) # [2, 2, 3, [10, 5]]
print(list2) # [1, 2, 3, [4, 5]]

常见方法

sorted(iterable, key=None, reverse=False) 返回对a排序后的新列表,a不变(任何可迭代对象)

a = (1,2,3,)
print(sorted(a, key=lambda x: -x)) # [3, 2, 1]
print(a) # (1, 2, 3)

sort([key=,][reverse = False])排序函数(列表)

• a.sort() 对列表a进行排序
• key定义排序规则，传入一个函数，函数的第一个参数为列表每一个元素

缺省规则排序

a = [3,6,2,5,4,1]
a.sort()
print(a) #[1, 2, 3, 4, 5, 6]

a.sort(reverse = True)

从大到小排序

a = [3,6,2,5,4,1]
a.sort(reverse = True)
print(a) # [6, 5, 4, 3, 2, 1]

自定义排序规则

def sort_list(x):
    return -x
x = [3,6,2,3,1,5,6]
x.sort(key = sort_list)
print(x) # [6, 6, 5, 3, 3, 2, 1]

• iterable 待排序对象
• key排序规则
• reverse 是否翻转
• 列表.append(元素) 向列表中追加元素
• 列表.extend(容器) 将容器中的元素分别取出，追加到列表末尾
• 列表.insert(下标,元素) 指定位置插入元素,其他元素后移
• del 列表[下标] 删除列表指定下标元素
• 列表.pop(下标)删除列表指定下标元素
• 列表.remove(元素)删除列表中第一个匹配项，不存在则抛出异常
• 列表.clear()清空列表
• 列表.count(元素) 返回元素出现的次数
• 列表.index(元素) 返回指定元素首次出现的下标，找不到报错
• 列表.index(x,s) 从s处开始查找元素x返回指定元素首次出现的下标，找不到报错

a = [1,2,3,4,5,6]
print(a.index(5, 3)) # 4

• len(列表) 返回列表长度
• 元素 in 列表 使用in运算符判断列表中是否包含某元素

列表加法

• 列表只能加列表

a = [1,2,3,4]
a += [5]
print(a) # [1, 2, 3, 4, 5]
a += [[5]]
print(a) # [1, 2, 3, 4, 5, [5]]

a += b 和 a = a + b不同

a = b = [1,2,3,4] #a与b指向同一个变量空间
a += [1] # 变量空间中添加新元素
print(a) # [1, 2, 3, 4, 1]
print(b) # [1, 2, 3, 4, 1]
a = a + [5]# 对a重新赋值，不影响b
print(a) # [1, 2, 3, 4, 1, 5]
print(b) # [1, 2, 3, 4, 1]

列表乘法

• list2 = list*n
• 把原列表写n遍，得到一个新的列表，与原列表没有任何关系

list = [1,2,3]
list2 = list*3
print(list2) # [1, 2, 3, 1, 2, 3, 1, 2, 3]
list[0] = 2
print(list2) # [1, 2, 3, 1, 2, 3, 1, 2, 3]

---

元组tuple

• 由数个，分割的值组成，前后可加括号
• 有序的数据集合
• 元组不可修改，即不可增删元素，不可修改元素顺序（不可排序）

t = 1,2,3,'123',[1,2,3]
t1 = (1,)
print(t[1]) # 2
print(t1) # (1,)
#元组的元素内容可能被修改
t[4][0] = 4
print(t) # (1, 2, 3, '123', [4, 2, 3])
t[1] = 0 # 元组的值不可被修改

+元组连接

*元组迭代

元组比大小

• 逐个元素比大小，直到分出胜负
• 如果有两个元素不可比大小，抛出异常

集合set

• 元素类型可以不同
• 不会有重复元素
• 可以增删元素
• 整数、小数、复数、字符串、元组都可以作为集合的元素，但是列表、字典和集合等可变数据类型不可做为集合元素
• 一个元组如果包含可变数据类型，也不能作为集合的元素
• 集合的作用是快速判断某个东西是否在一堆东西里面（用in）

集合常用函数

• set.add(x) 给集合set添加元素x，如果x已存在则不添加
• set.clear()清空集合set里的内容
• set.copy()返回集合set的浅拷贝
• set.remove(x) 从集合set中删除元素x，不存在x则抛出异常
• set.update(x) 将序列x中的元素加入到集合

集合运算(a和b是集合)

• x in a x是否在集合中
• a|b 返回a和b的并
• a&b 返回a与b的交集
• a-b 返回a与b的差
• a^b a和b的对称差 等价于(a|b) - (a&b)

字典dict

• 无序记录一堆k-v对的数据集合
• d = {key1 : value1,key2 : value2...}
• 字典元素的值是可赋值的，因此也是指针
• 所有元素的key都不相同(内容不能以一样，地址不一样内容一样也不行)
• key必须是不可变类型，如 字符串、整数、小数、元组
• 一个元组如果包含可变数据类型，也不能作为字典的key
• 列表、集合、字典等可变的数据类型，不可做为字典元素的键
• del dt['Mike'] 删除键为Mike的元素
• dt['a'] = b 给字典dt添加键值对
• 'a' in dt 判断字典中是否有key为a的k-v对

dt = {'zhangsan':100,'lisi':90,'wangwu':97}
dt['wangjiu'] = 200
print(dt['zhangsan']) # 100
print('zhangsan' in dt) # True
print('zhaoliu' in dt) #False
print(dt.get('赵六','不存在')) # 不存在
print(dt.get('赵六',0)) # 0
print(dt.get('wangjiu',0)) # 200
print(dt) # {'zhangsan': 100, 'lisi': 90, 'wangwu': 97, 'wangjiu': 200}

item = [('name','zhangsan'),('age',13)]
dt = dict(item)
print(dt) # {'name': 'zhangsan', 'age': 13}
dt2 = dict(name='lisi',age=20,sex='man')
print(dt2) # {'name': 'lisi', 'age': 20, 'sex': 'man'}

字典的函数

• dt.get(k,v2) dt中存在key为k的k-v对则返回v，否则返回v2
• dt.clear() 清空字典dt
• dt.keys() 返回字典key序列
• dt.items()返回字典元素序列
• dt.values()返回字典value序列
• dt.copy()浅拷贝
• copy.deepcopy(dt)深拷贝
• dt.pop(x)删除键为x的元素，如不存在，抛出异常

• • 同del dt[xxx]

dt = {'zhangsan':100,'lisi':80,'wangwu':90}
del dt['lisi']
print(dt) # {'zhangsan': 100, 'wangwu': 90}
dt.pop('zhangsan')
print(dt) # {'wangwu': 90}
del dt['awdsda']
dt.pop('zhaoliu')

字典遍历

• 在python3.5前顺序不确定.3.6以后顺序同加入字典的顺序

dt = {'zhangsan':100,'lisi':80,'wangwu':90}
for key in dt.keys():
    print(dt[key])
for item in dt.items():
    print(item[0])
    print(item[1])

---

注释

单行注释 # 建议后面加个空格

多行注释：三个单引号或双引号

# 我是注释
'''
我是多行注释
'''
print("123","456",end='')

---

复杂数据类型常用方法

切片.[start:end:step]（元组，列表，字符串）

列表比大小

• 逐个元素比大小，知道分出胜负
• 如果两个对应元素不可比大小，抛出异常

列表映射map(function,sequnence)

• function回调函数指定映射规则
• sequnence是要处理的原数据
• 返回值一个延时求值对象，该对象被转化为list/tuple/set...后数据被清空

a = (1,2,3)
a = list(map(lambda x:x*x,a))# [1, 4, 9]
print(a)
a = (1,2,3)
a = set(map(lambda x:x*x,a))# {1, 4, 9}
print(a)
a = (1,2,3)
a = tuple(map(lambda x:x*x,a))
print(a) # (1, 4, 9)

x,y,z = map(lambda x:int(x),input("请输入三个数字用,隔开").split(','))
print(x,y,z) # 1 2 3
x,y,z = map(int,input("请输入三个数字用,隔开").split(','))
print(x,y,z) # 1 2 3

列表过滤filter(function,squence)(列表、元素、集合)

• function，回调函数,true则返回
• squence，待处理序列（列表、元素、集合）
• 返回一个演示求职对象，该对象被转化为list/tuple/set...后数据被清空

a = [1,2,3,4,5,6]
b = list(filter(lambda x:x%2 == 0,a))
print(b) # [2,4,6]

---

数据类型转换

转换语句

• 转整数 int(x)
• 转浮点数 float(y)
• 转字符串 str(y)
• eval(z) : 把字符串z看作一个python表达式，求其值

a. 任何数据类型都可以转换为字符串

b. 只有数字字符串才能转换为数字(包括小数)

c. 浮点数转整数会丢失小数

---

变量

Python中的变量都是指针

• Python中所有可赋值的东西，即可以出现在赋值号"=" 左边的东西，都是指针
• 指针即代表内存单元的地址
• 将指针称作“箭头”,更容易理解。所有变量都是箭头，指向内存某处
• 对变量进行赋值的本质，就是让该变量（箭头）指向某个地方

使用del关键字删除变量

del 变量名

a = 1
print(a)
del a
print(a)
'''
1
Traceback (most recent call last):
  File "C:\Users\wangr\OneDrive - Ludhiana Group Of Colleges\My_Code\python\python01\test01.py", line 4, in <module>
    print(a)
NameError: name 'a' is not defined

'''

标识符

允许的元素：

• 英文
• 中文
• 数字
• 下划线

命名规则

• 不推荐使用中文
• 不可以数字开头
• 大小写敏感
• 不可使用关键字

• • False True None and as assert break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield

命名规范

• 见名知意
• 下划线命名法

• • student_name
  • first_num

• 英文字母全小写

---

运算符

算数运算符

• +
• -
• *
• /

• • / 的结果一定是小数

• // 整除
• % 区域
• ** 求n次方

print(5//3)//1
print(5**3)//125

赋值运算符

• =
• +=
• -+
• *=
• /=
• //=
• &=
• **=

比较运算符

• == !=
• > <
• >=大于等于 <=小于等于

is 运算符和 == 的区别

• a is b 为True 说a和b指向同一个地方
• a == b 为True 说明a和b指向的地方放的的东西相同，但是a 和b不一定指向相同的地方
• a = b 会使得a和b指向同一个地方

逻辑运算符

not

and

or

优先级 not > and > o

全部存在短路

相当于True(只有1等于True)

• 非0数
• 非空字符串
• 非空列表

相当于False(只有0等于False)

• 0
• ""空字符串
• []空表
• None

print( [] == False)# false
print( not [])#true
print( 0 == False)#true
print( 1 == True)#true
print( not "")#true

不同数据类型之间的运算

数值型从简单到复杂排序

1. bool
2. int
3. float
4. complex

1. ==运算符会把箭头左边的类型转换为箭头右边的类型，再进行运算

2.

3. is操作符需要同时类型和值两者相同才为True，否则为False

4. +操作符会把右边的类型转换为左边的类型，再进行运算

---

输入输出

输入

input("提示性语句")

• 返回值是字符串

输出

printf()

去掉末尾的换行符

print("末尾无换行符",end='')

输出多份内容

money = 50
print("还剩",money-10-5,'元')

三大结构

顺序结构

选择结构

a = 1
if a>5:
    print('a>5')
elif a>3:
    print('a>3且a<=5')
else :
    print('a<=3')

循环结构

while

n = 1
s = 0
while n<=100:
    s += n
    n += 1
print('1加到100的值为',s)

for循环

x = 0
for x in range(0,2,1):
    print(x)
print(x)
'''
0
1
1'''

• 临时变量作用域为循环内
• 如需在变量外访问，需要提前在循环外定义

range(头，尾，步长)语句

• 含头不含尾

循环中断

continu跳过当前循环

break结束本层循环

函数

自定义函数

'''
def (形参):
    函数体
    return 返回值
'''
def say(name):
    print("我的名字是",name)
    return 1
print(say("张三"))
'''
我的名字是 张三
1
'''

• 先定义后调用
• return后的代码不会执行
• return None表示返回空
• 不写return语句等同于返回None

将函数内生命的变量声明为全局变量global

a = 10
def say():
    # 声明a是全局变量
    global a
    # 定义一个全局变量b
    global b
    a = 2
    b = 100
    print('hello')
say()
print(a)
print(b)
'''
hello
2
100
'''

函数中可以直接修改可变数据类型的值，无需声明为全局变量

arr1 = [1,2,3,4,5]
def method1():
    arr1[0] = 3
    print(arr1)
method1()# [3, 2, 3, 4, 5]
print(arr1) # [3, 2, 3, 4, 5]

可变参数

def sum (*args):
    sum = 0
    for x in args:
        sum +=x
    return sum
print(sum(1,2,3,4,5))# 15

---

异常

try :
    awdasd
except:
    print("出异常了")

---

文件

文本文件读写

1. open(path,type,encoding=)打开文件，将返回值放入一个变量

1. 1. path:文件路径\要用\\(转义)
   2. type:

1. 1. 1. 'r' 文本文件读
      2. 'rb' 二进制文件读
      3. 'w' 文本文件写
      4. 'wb' 二进制文件写
      5. 'r+' 文本文件既读又写
      6. 'rb+' 二进制文件既读又写

1. 1. encoding:

1. 1. 1. utf-8
      2. gbk

1. f.write()写入文件
2. 读取文件(读取文件一行,每读一次，指针偏移一行)

1. 1. f.readlines()读取全部文件内容
   2. f.readline()
   3. f.read()读取全部文件内容，返回一个字符串，包含文件全部内容

f = open('C:\\Users\\wangr\\Desktop\\test.txt',encoding='UTF-8')
# 获取全部文本内容
str1 = f.read()
str = f.readline()
print(str1) #能读到所有内容（共五行）
# 指针已经偏移到末尾了，读出来是空
print('str1=',str) # str1=
# 关闭文件
f.close()

f = open('C:\\Users\\wangr\\Desktop\\test.txt',encoding='UTF-8')
for x in f:
    print(x,end='')
f.close()

1. f.close()关闭文件