python基础

30+11

已于 2024-07-25 19:13:39 修改

阅读量671

点赞数 13

分类专栏： python学习文章标签： python 开发语言

于 2024-07-25 16:33:49 首次发布

本文链接：https://blog.csdn.net/qq_53905637/article/details/140671503

版权

python学习专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、基本语法和变量和输入和输出

1.1 变量的赋值

python是弱类型语言，创建变量的时候不用去声明变量的类型

a=10  #a是变量的名字  =是赋值符号  10是值

#传递赋值
a=b=c=10 

#多变量赋值
a,b,c=10,20,30  #a=10,b=20,c=30

#交换赋值
a=10
b=20
a,b=b,a    #a=20 b=10

#自增赋值
a=a+1   
a+=1  #相当于a=a+1 
a*=4  #相当于a=a*4
a/=2  #相当于a=a/2

1.2 变量的命名

只能是数字、英文、下划线组成
数字不能开头
遵循下划线命名法或者驼峰命名法
在python中大写和小写是区分的

# 创建一个存储学生数学分数的变量
stu_math_score=90 #下划线命名法
stuMathScore=90   #驼峰命名法

1.3 注释

行注释：#注释的内容

段落注释：三引号 '''注释的内容''' """注释的内容"""

1.4 输出和输入

1.输出：print() 把(.....)里面的内容打印到控制台

a=20
b=30
c='hello'
print(a,b,c,'world',1.6666)  #输出结果为20 30 hello world 1.6666

# end参数是输出的连接符号，这是打印不换行
print('hello',end='-')
print('world')        #输出结果为hello-world

#end参数可以等于任何字符，end='/',输出结果为hello/world

2.输入：input('提示信息')

n1=input('请输入一个数字：')
n2=input('再输入一个数字：')
print(n1+n2)     #n1输入7，n2输入8，打印结果是78

这是因为input() 输入的内容默认都是字符串，字符串相加，就是进行拼接的操作。如果要进行数字的计算，需要转换输入的数据类型。

n1=float(input('请输入一个数字：'))
n2=float(input('再输入一个数字：'))
print(n1+n2)

float() 是浮点数，包含了整数和小数两个部分。

int() 是整数，只有整数部分，不能进行小数点的计算。

二、数据类型

2.1 布尔类型 bool

布尔类型只有真和假两个数据。

真 True

假 False

2.2 数字类型

整数类型（整型） int()

小数类型（浮点型） float()

基本运算:+   -    *   /   

取余数运算:   %

取整数运算:  //

幂运算:  **

在Python中，小数运算通常容易出现浮点数误差，例如 0.1+0.1+0.1-0.3 就不等于0，所以很多时候都需要对小数精度进行限制：

round() ：保留小数精度

round(0.00232343,4) --保留4位小数，0.0023

print(0.1+0.1+0.1-0.3, 2) #结果为5.551115123125783e-17

print(round(0.1+0.1+0.1-0.3, 2))  #结果为0.0

2.3 字符串 str

单引号和双引号的作用是一模一样的，三引号字符串可以包含换行之类的特殊符号

a='hello'
b="hello"

c='''hello
world'''  

'''结果为:
hello
world
'''

d='''hello
     world'''   

'''结果为：
 hello
     world
'''

\(转义符)

当要定义一个字符串，但这个字符串太长时，可以用\代表换行


a='https://image.baidu.com/search/index?tn=baiduimage&' \
  'ipn=r&ct=201326592&cl=2&lm=&st=-1&fm=index&fr=&hs=0' \
  '&xthttps=111110&sf=1&fmq=&pv=&ic=0&nc=1&z=&se=&showtab=' \
  '0&fb=0&width=&height=&face=0&istype=2&ie=utf-8&word=%E7%9' \
  '4%B5%E8%84%91%E5%A3%81%E7%BA%B8'

当\已文件路径中的时候

path="E:\test\notepad.txt"
print(path)     #这个时候\为转义符，识别不了路径

# 第一种处理方式，在反斜杠前面再加一个反斜杠
path="E:\\test\\123.txt"
print(path)
# 第二种处理方式，在字符串的最前面加上r，表示让转义符失效
path=r"E:\test\123.txt"
print(path)

字符串常用的方法：

字符串和其他的所有类型在函数操作的时候都不一样，字符串的函数操作结果是临时存在的，不是永久修改的，只有在函数运行的一瞬间操作的结果是对应的。

replace() :替换字符串
find() :在字符串中查询其中包含的字符（串），Python数数都是从0开始的
count() :对字符串的内容进行统计
upper() :转换为大写
lower() :转换为小写
title() :首字母大写
split()：拆分字符串。通过指定分隔符对字符串进行切片并返回分割后的字符串列表（list）
os.path.split()：按照路径将文件名和路径分割开

a='hello world'


print(a)      #hello world
b=a.split(' ')　　#用空格分隔字符串ａ　　　　　
print(b)     #['hello', 'world']

# 转换大小写
print(a.upper())  #HELLO WORLD
print(a.lower())  #hello world
print(a.title())  #Hello World

# 替换字符串
print(a.replace('l','X'))  #heXXo worXd
print(a.replace(' ',''))  #替换字符串中的空格，结果为helloworld

# 查询包含的字符串，Python数数都是从0开始的，oracle数据库从1开始的
print(a.find('or'))    #空格也算一个字节，结果为7

# 对字符串的内容进行统计
print(a.count('o'))   #2

下面是字符串的各种判断方法，返回的结果都是True或False

# 字符串的各种判断，返回的结果都是True或False
#判断开头的组成
print(a.startswith('H'))
#判断结尾的组成
print(a.endswith('ld'))
#判断字符串是否是全数字
print(a.isdigit())
#判断字符串是否由英文和中文组成
print(a.isalpha())
#判断英文是否都是大写
print(a.isupper())
print(a.islower())

对字符串的内容进行格式化操作

name=input('输入名字：')
age=input('输入年龄：')
print('欢迎你{}，你今年的年龄是{}岁了'.format(name,age))
print(f'欢迎你{name}，你今年的年龄是{age}岁了')
print('欢迎你%s，你今年的年龄是%s岁了'%(name,age))

2.4 列表类型 list

列表不是单个的独立的数据，是由很多的数据共同组成的一个组合体。

#定义列表
li=[10,100,20,30]
print(li)

li01=[10,2.333,'curry']
print(li01)

列表常用的方法：

append() :追加数据到列表的最后面
insert() :指定某个位置去插入数据
pop() :根据位置来删除数据
remove() :根据具体的内容来删除数据，remove()只会删除多个数据中匹配的第一个内容
sort() :对列表的内容进行排序，排序列表只能是相同的数据类型。sort()默认是升序排序，sort(reverse=True) 降序，reverse是反向的意思
count() :对列表的内容进行统计
clear() :清空列表
修改某个具体位置的数据列表名字[序号]=新的值

li=['西瓜',100,1.888,'curry']

# 新增数据到列表中
#默认追加数据到列表的最后面
li.append('西瓜')
print(li)       #['西瓜', 100, 1.888, 'curry', '西瓜']
#指定某个位置去插入数据
li.insert(1,'james')
print(li)       #['西瓜', 'james', 100, 1.888, 'curry', '西瓜']

# 删除列表的数据
#根据位置来删除数据
li.pop(2)
print(li)  #2对应的100，  ['西瓜', 'james', 1.888, 'curry', '西瓜']
#根据具体的内容来删除数据，remove()只会删除多个数据中匹配的第一个内容
li.remove('西瓜')
print(li)    #['james', 1.888, 'curry', '西瓜'] 第一个西瓜被删除了

# 修改某个具体位置的数据    列表名字[序号]=新的值
li[2]='你好'  
print(li)   #['james', 1.888, '你好', '西瓜'] li[2]原本等于'curry'，被修改为了'你好'

# 对列表的内容进行排序，排序列表只能是相同的数据类型
li02=[4,8,2,1,9]
li02.sort()   #sort()默认是升序排序
print(li02)   #[1, 2, 4, 8, 9]
li02.sort(reverse=True)  #reverse是反向，True打开反向的操作
print(li02)   #[9, 8, 4, 2, 1]

li03=['dc','ab','abc','adc','ace','acc']  #字符串是根据计算机里面的ascii码来排序的
li03.sort()  
print(li03)   #['ab', 'abc', 'acc', 'ace', 'adc', 'dc']

# 对列表的内容进行统计
li04=['aa','bb','cc','aa']
print(li04.count('aa'))   #2
# 清空列表
li04.clear()
print(li04)  #[]

深拷贝和浅拷贝：

浅拷贝：将a变量的内存中的地址，复制给b，这个时候修改a的内容，b的数据也会一起发生变动。

li01=[1,2,3,4]
li02=li01    #只是复制地址
print(li01) #[1, 2, 3, 4]
print(li02) #[1, 2, 3, 4]

li01[0]=100  #修改li01[0]的值为100
print(li01) #[100, 2, 3, 4]
print(li02) #[100, 2, 3, 4]

深拷贝：将a的值，复制给b，让b在内存中开一个新的地址去存储数据。这个时候修改a的内容，b的数据不会一起发生变动。

li01=[1,2,3,4]
li02=li01[:]   #复制的是列表01从开始到结束的所有内容
print(li01)  #[1, 2, 3, 4]
print(li02)  #[1, 2, 3, 4]

#修改后
li01[0]=100  
print(li01)  #[100, 2, 3, 4]
print(li02)  #[1, 2, 3, 4]

2.5 元组类型 tuple

和列表一样，也是各种不同数据的组合体，列表可以新增、删除、修改、排序等，但是元组只要被定义了，就不能修改它的内容。元组是不可变的数据类型。

typre() ：打印t的数据类型

如果元组是只有一个元素，那么在括号里面一定要加上逗号：

t=(1,)
print(type(t))   #<class 'tuple'>表示t是元组类型

2.6 切片查询（前闭后开）

字符串+列表+元组有一个共同的进行查询的方法：切片查询

根据一个具体的序号位置来查询数据：

s='CURRY IS MVP'
#查询字符串的某个位置的内容
print(s[0])   #C
print(s[2])   #R
print(s[-1])  #P

根据开始和结束的范围来查询数据：

s='JAMES VS CURRY'
print(s[2:5])    #MES　

＃S[2:5]是前闭后开区间

在范围中添加步长的概念：

s='JAMESVSCURRY'
#使用步长在范围内进行取值
print(s[2:10:2])　＃MSSU

如果步长是负数，那么取数就是从后往前取：

s="abcdefghijklmn"

print(s[-1:-4:-1])  # nml

print(s[-2:-7:-2])  # mki

如果开始位置为空，表示从0开始取值；结束位置为空，表示截取到最后一位：

s="abcdefghijklmn"
print(s[:5])   #abcde
print(s[5:])   #fghijklmn
print(s[:])    #abcdefghijklmn
print(s[::-1]) #nmlkjihgfedcba

列表和元组切片查询语法和原理是一模一样的：

s=('aa','bb','cc','dd','ee','ff','gg')
print(s[2:5])    #('cc', 'dd', 'ee')

2.7 字典类型　 dict

日常见到的菜单就是一个字典的类型。字典是一种键值对类型，由关键字和对应的值共同组成的，在一个字典中关键字是不会重复的，值都是对关键字的描述。

key-value类型，也叫做映射类型。

字典是一种无序的数据类型，本身是没有序号的概念的。

字典常用的方法：

新增键值对的内容字典名字[新的关键字]=值
修改关键字对应的值字典名字[已存在的关键字]=新值
keys()　　：查询字典的所有的关键字
values()　：查询字典中所有的值
get('关键字')　或者　字典名字[已存在的关键字]　　：查询特定关键字的值
clear()　　：清空字典
pop()　　：删除某个键值对

menu={'蛋炒饭':12,'猪脚饭':15,'木桶饭':14}
print(menu)            #{'蛋炒饭': 12, '猪脚饭': 15, '木桶饭': 14}

# 新增键值对的内容   字典名字[新的关键字]=值
menu['酸辣土豆丝']=15   
print(menu)            #{'蛋炒饭': 12, '猪脚饭': 15, '木桶饭': 14, '酸辣土豆丝': 15}

# 修改关键字对应的值   字典名字[已存在的关键字]=新值
menu['猪脚饭']=18  #因为关键字不能重复，所以新的数据覆盖了旧的数据
print(menu)            #{'蛋炒饭': 12, '猪脚饭': 18, '木桶饭': 14, '酸辣土豆丝': 15}

# 查询字典的所有的关键字
print(menu.keys())     #dict_keys(['蛋炒饭', '猪脚饭', '木桶饭', '酸辣土豆丝'])
# 查询字典中所有的值
print(menu.values())   #dict_values([12, 18, 14, 15])

# 查询特定关键字的值
print(menu['酸辣土豆丝'])          #15
print(menu.get('酸辣土豆丝'))      #15

# 删除某个键值对
menu.pop('蛋炒饭')         
print(menu)             #{'猪脚饭': 18, '木桶饭': 14, '酸辣土豆丝': 15}

# 清空字典
menu.clear()
print(menu)            #{}

2.8 集合类型 set

集合是一种没有重复数据的数据类型。也是一种无序的数据类型。

# 空的集合，需要使用 set() 来表示
s=set()
print(s)

集合的常用方法：

s1={100,200,100,200,300}
print(s1)　　　#{200, 100, 300}

# 添加数据
s1.add('hello')   # add是将数据当成一个整体来添加
print(s1)　　　　#{200, 'hello', 100, 300}
s1.update('welcome')  # update是将数据拆分成一个个的字符进行添加
print(s1)　　　　　#{100, 'e', 'c', 200, 'w', 300, 'l', 'hello', 'o', 'm'}

# 删除集合中的数据
s1.remove('hello')   # remove是指定具体的内容来删除
print(s1)　　　　#{100, 'e', 'c', 200, 'w', 300, 'l', 'o', 'm'}
s1.pop()     # pop是删除集合中的第一个数据
print(s1)　　　　#{'e', 'c', 200, 'w', 300, 'l', 'o', 'm'}

在工作中可以使用set()进行列表和元组数据的去重：

li=[100,200,300,200,100]
print(list(set(li)))　#{200, 100, 300}