【Python基础知识(学习笔记)】

已于 2023-05-16 19:17:54 修改
阅读量174 收藏 1
点赞数 1
分类专栏： python 文章标签： python 开发语言
于 2023-05-12 19:42:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63719860/article/details/130649036
版权

Python基础知识(学习笔记)

运算符

与或非：and,or,not.

python的空值以及内置函数的返回值

a = None
# None不能进行运算
print(a+1) # 会报错
b = print("1234")
# 输出为None

字符串–切片

name = "你看起来很好看"
print(name[0:3])
# 取左不取右
# 输出>>>你看起
print(name[-3:-1])
# 输出>>>很好
print(name[-3:])
# 输出 >>>很好看
print(name[:])
# 输出>>>你看起来很好看
print(name[0:5:2])
# 输出>>>你起很
# 冒号左中右分别为下标，下标，步长
print(name[::-1])
# 输出>>>看好很来起看你

字符串–拼接

a = '100'+'50'
# 10050
b = "我的名字叫11"
c = "很高兴认识大家"
d = "希望大家多多关照"
f = ','.join((b,c,d))
print(f)
# 输出>>>我的名字叫11,很高兴认识大家,希望大家多多关照

字符串–格式化

s2 = "大家好，我的名字叫{}，今年{}岁，性别{}".format("逍遥","18","男")
print(s2)
# 大家好，我的名字叫逍遥，今年18岁，性别男
s3 = "大家好，我的名字叫{}，今年{}岁，性别{}"
print(s3.format("逍遥","18","男"))
# 大家好，我的名字叫逍遥，今年18岁，性别男
s4 = "大家好，我的名字叫{1}，今年{0}岁，性别{2}"
# 数组为下标，括号从左往右数以此为0，1，2...
print(s4.format("逍遥","18","男"))
# 大家好，我的名字叫18，今年逍遥岁，性别男

字符串的常用方法–find&count

"""
find:查找元素位置
查找字符串片段在字符串的下标位置，从前往后找，返回的是第一个被找到字符串片段的起始位置
第一个参数：要查找的字符串片段
第二个参数：要查找的起始位置
第三个参数：要查找的终止位置-1
如果查找的字符串存在多个，查找结果是第一个出现的字符串下标，找不到就返回-1

count:统计字符串片段，在字符串中出现的次数，找不到就返回0
"""
s1 = "pythonMuzhou"
print(s1.find("o"))
# >>> 4
print(s1.find("o","6","11"))
# >>> 10
s2 = "pythonMuozhou"
print(s2.find("o","6","11"))
# >>> 8
print(s1.find("a"))
# >>> -1
print(s1.count("o"))
# >>> 2
print(s1.count("o","6","11"))
# >>> 1
print(s2.count("o","6","11"))
# >>> 2
print(s1.count("a"))
# >>> 0

字符串–replace&upper%lower

"""
replace:替换指定的字符串片段
参数1：要替换的字符串片段
参数2：替换之后的字符串片段
参数3：替换的次数，从前往后替换(默认替换所有的)

upper:将字符串内多有的小写字母转为大写
lower:将字符串内所有的大写字母转成小写
(如果自己本身字符串有大写/小写则不发生任何变化)
"""
s1 = "python to muzhou"
res = s1.replace('o','TT')
print(res)
# >>> pythTTn tTT muzhTTu
res1 = s1.replace('o','TT',1)
print(res1)
# >>> pythTTn to muzhou
res2 = s1.replace('o','TT',2)
print(res2)
# >>> pythTTn tTT muzhou
res3 = s1.upper()
print(res3)
# >>> PYTHON TO MUZHOU
res4 = res3.lower()
# >>> python to muzhou

字符串–split&strip

"""
split:指定分割点对字符串进行分割
参数1：分割点
参数2：分割的次数(默认找到所有的分割点进行分割)

strip:去除字符串首尾的空格
s2 = '		python:666		'
"""
s1 = "111ab222ab333ab444"
# 将字符串，用规定的字符"a"进行分割，得到一个列表
print(s1.split('a'))
# >>> ['111', 'b222', 'b333', 'b444']
print(s1.split('a',2))
# >>> ['111', 'b222', 'b333ab444']
s2 = '		python:666		'
print(s2.strip())
# >>> python:666
s3 = '6666python:6666'
print(s3.strip('6'))
# >>> python:
s4 = '		1234qwer	54321trewq'
print(s4.strip())
# >>> 1234qwer	54321trewq
print(s4.replace(' ',''))
# >>> 1234qwer54321trewq

传统的格式化输出&F表达式

"""
传统的格式化输出法：%
%s：为字符占位，任意类型都可以
%d:为数值类型占位
%f：为浮点数占位
s1 = "%s---%d---%f"%('a','b','c')

F表达式(F、f都一样，pithon3.6以上支持)
	name = '睦州'
	age = 18
	s3 = F"我的名字{name},年龄{age}"
	print(s3)
"""
s1 = '我%s你'%('爱')
print(s1)
# >>> 我爱你
s2 = '我的成绩%d'%(100)
print(s2)
# >>> 我的成绩100
s3 = '我的成绩%d'%(99.99)
print(s3)
# >>> 我的成绩99
s4 = '我的零花钱%f'%(99.99)
print(s4)
# >>> 我的零花钱99.990000

name = '睦州'
age = 18
s5 = F"我的名字{name},年龄{age}"
s6 = "我的名字{},年龄{}".format(name,age)
print(s5)
# >>> 我的名字睦州,年龄18
print(s6)
# >>> 我的名字睦州,年龄18

字符串format的进阶用法

"""
len():字符串的长度
format:格式化输出(进阶)
	1、格式化小数长度(会四舍五入)			    :.2f
	2、将小数按百分比的形式显示(会四舍五入)		:.2%
	s = 3.6567
"""
s1 = "python"
print(len(s1))
# >>> 6 (如果有空格的话，空格也算)
s2 = 3.6567
x = 5.6567
print("今天的橘子{}钱一斤".format(s2))
# >>> 今天的橘子3.6567钱一斤
print("今天的橘子{:.2f}钱一斤".format(s2))
# >>> 今天的橘子3.66钱一斤
print("今天的橘子{:.2f}钱一斤".format(s2,x))
# >>> 今天的橘子3.66钱一斤
print("今天的橘子{1:.2f}钱一斤".format(s2,x))
# >>> 今天的橘子5.66钱一斤
print("今天的橘子{0:.2f}钱一斤".format(s2,x))
# >>> 今天的橘子3.66钱一斤
print("百分比为{:.2%}".format(0.656755))
# >>> 百分比为65.68%
print("百分比为{:.3%}".format(0.656755))
# >>> 百分比为65.676%

定义列表

# 列表内的数据类型可以不同
list = [1,2,3,4,"我爱你",[10,20,30,40]]
print(list[0])
# >>> 1
print(list[4])
# >>> 我爱你
print(list[5])
# >>> [10,20,30,40]
print(list[5][1])
# >>> 20

列表的长度和更新列表

# 列表中的值是可以改变的
list_1 = [20,30,40,50,60,70]
print(len(list_1))
# >>> 6
list_1[2] = 99
print(list_1)
# >>> [20,30,99,50,60,70]

列表的加法和乘法操作

list_1 = [10,20,30]
list_2 = [5,6,7]
print(list_1+liat_2)
# >>> [10,20,30,5,6,7]
print(list_1*3)
# >>> [10,20,30,10,20,30,10,20,30]
print("我爱你"*3)
# >>> 我爱你我爱你我爱你

列表的切片取值

# 类似字符串的切片(取左不取右)
list_1 = [10,20,30,40,50,60,70]
print(list_1[0:3])
# >>> [10,20,30]
print(list_1[-3:-1])
# >>> [50,60]
print(list_1[-3:])
# >>> [50,60,70]
print(list_1[:])
# >>> [10,20,30,40,50,60,70]
print(list_1[1:6])
# >>> [20,30,40,50,60]
print(list_1[1:6:2])
# >>> [20,40,60]
print(list_1[-6:-1])
# >>> [20,30,40,50,60]
print(list_1[-6:-1:2])
# >>> [20,40,60]
print(list_1[::-1])
# >>> [70,60,50,40,30,20,10]

列表的操作方法–del&append

"""
1、del:关键字	删除
2、append:方法
	append函数用于向列表末尾添加元素
"""
a = [1,2,3]
del a
# 在计算机(内存)当中 a变量定义的列表 删除
print(a)
# 会报错
del a[1]
# 删除掉列表中的指定值
print(a)
# >>> [1,3]
a.append(4)
print(a)
# >>> [1,2,3,4]

列表的操作方法–inrsert&clear

"""
1、insert方法：
	insert函数用于向列表中插入元素
	insert函数的第一个参数是插入的位置，第二个参数是要插入的对象
2、clear函数用于将列表清空
"""
list_1 = [20,30,40,50]
list_1.insert(2,[11,22,33])
print(liat_1)
# >>> [20,30,[11,22,33],40,50]
list_1.insert(2,99)
print(list_1)
# >>> [20,30,99,40,50]
list_1.clear()
print(list_1)
# >>> []
print(len(list_1))
# >>> 0

列表的操作方法–remove&pop

"""
1、remove函数：
	remove函数用于从列表移除元素
	注意：执行结果如下，可以看到，若列表中有重复元素，remove函数只会移除匹配到的第一个
2、pop函数：
	pop函数用于一处列表中指定位置的元素，并返回要移除的元素
	在默认情况下，移除列表中最后一个元素
"""
a = ["hello","world","python","hello"]
a.remove("hello")
print(a)
# >>> ['world','python','hello']
a.pop(3)
# 3为下标
print(a)
# >>> ['hello','world','python']
print("要移除的数据：",a.pop(3))
# >>> hello

列表的操作方法–index&reverse

"""
1、index函数：
	index函数用于返回所匹配的元素的索引。该函数的第一个参数是待查找的对象，第二个参数是查找的起始范围，第三个参数是查找的结束范围
2、reverse函数
	reverse函数用于将列表反向排列
"""
a = ["hello","world","hello","python"]
r  = a.index('hello')
print(r)
# >>> 0
# 只会去匹配第一次，并返回它的下标
r2 = a.index('hello',1,3)
print(r2)
# >>> 2
a.reverse()
print(a)
# >>> ["python","hello","world","hello"]
print(a[::-1])
# >>> ["python","hello","world","hello"]

列表的操作方法–extend

"""
extend方法：
	extend函数用于在列表的末尾添加另一个列表。
	与append函数相比，extend函数可以一次性添加多个元素
	注意：使用extend函数和列表加法的结果是一样的，但是使用extend函数会将另一个列表并入当前列表，而列表加法是返回新的列表，为节约内存空间，更推荐使用extend函数来实现大列表的连接操作。
"""
a = [10,20,30]
b = [1,2,3]
a.extend([1,2,3])
# 在原列表中进行相加
print(a)
# >>> [10,20,30,1,2,3]
a.append([1,2,3])
print(a)
# >>> [10,20,30,[1,2,3]]
c = a + b
# 不是在原列表中相加，而是返回新的列表，是会占据内存空间的
# 为节约内存空间，建议使用extend方法
print(c)
# >>> [10,20,30,1,2,3]

列表的操作方法–copy

"""
copy函数:用于创建列表的副本
"""
a = ["hello","world","hello","python"]
b = a.copy()
del a[0]
print('删除a[0]元素之后，输出b列表:',b)
# >>> 删除a[0]元素之后，输出b列表:["hello","world","hello","python"]
b = a
del a[0]
print('删除a[0]元素之后，输出b列表:',b)
# >>> 删除a[0]元素之后，输出b列表:["world","hello","python"]

列表的操作方法–sort

"""
sort函数:用于将列表进行排序
	如果都是字符串则是按照ASCII码进行排序
	常见ASCII码的大小规则：0~9<A~Z<a~z
	想使用a.sort(),必须确保a列表中是同类型的数据，是整数都是整数，是字符串都是字符串
	a.sort()--默认是升序
	a.sort(reverse=True)--进行翻转--则为降序
"""

列表的操作方法–count

"""
count函数：用于统计某个元素在列表中的次数
"""
a = ["hello","world","hello","python"]
r = a.count("hello")
print(r)
# >>> 2
r1 = a.count("h")
print(r1)
# >>> 0

元组的创建&元组与列表的不同

"""
元组的元素不能修改，写在小括号里面，元素之间是用','隔开，元组中元素类型可以不相同
元组：
	1、元组也是一种数据容器，使用小括号"()"表示，其使用场景与列表相似，这意味着能使用列表的地方，基本上都能使用元组，包括列表推导式、切片等操作。元组与列表的唯一区别是元组不可变的。
	2、元组的元素类型可以不统一
"""
t = ("hello",66,-20,3.66,[10,20,30])
print(t[1])
# >>> 66
t[1] = 88
print(t)
# >>>报错，原因：不支持对元组中元素进行修改

元组的加法以及元组中列表的数据更新

t1 = ("hello","world","python")
t2 = ([1,2],[3,4],[5,6,7,8])
t3 = t1 + t2
print(t3)
# >>> ("hello","world","python",[1,2],[3,4],[5,6,7,8])
t3[3][0] = "123456"
print(t3)
# >>> ("hello","world","python",[123456,2],[3,4],[5,6,7,8])

元组列表字符串的一些共同操作

"""
len(),max(),min()
"""
# 元组
a = (1,2,3,4)
print(len(a))
# >>> 4
print(max(a))
# >>> 4
print(min(a))
# >>> 1
# 列表
b = [10,20,30,40]
print(len(b))
# >>> 4
print(max(b))
# >>> 40
print(min(b))
# >>> 10
# 字符串
c = "12345我abcABC"
print(len(c))
# >>> 12
print(max(c))
# 字符串会转换成相应的ASCII码值
# >>> 我
print(min(c))
# >>> 1

元组的注意事项以及乘号的使用

a = (1,2,3,4)
b = 10,20,30
c = (10)
c1 = (10,)
print(b)
# >>> (10,20,30)
# 元组括号省略也可以
print(c)
# >>> 10
print(c1)
# >>> (10,)
# 定义单个元组时要在后面写一个逗号
d = (20,)
print(d*10)
# >>> (20,20,20,20,20,20,20,20,20,20)

集合的创建&数据去重

"""
集合：
	集合是无序的，集合中的元素是唯一的，集合一般用于元组或者列表中的元素去重，集合中默认去重。
	创建集合：
		1、变量名 = set(元素)		字符串/列表/元组/字典
		2、变量名 = {元素，元素，，，}		元组/字符串/数字
		3、元素是唯一的，用于列表的去重(去重的话用set()更方便，用大括号有局限)
"""
# 字符串
a = set("1234")
print(a)
# >>> {'1','2','4','3'}
# 列表
b = set([10,20,30])
print(b)
{10,20,30}
# 元组
c = set((1,2,3,4))
print(c)
# >>> {1,2,3,4}
# 字典
d = {
    "年龄":18,
    "名字":"aa"
}
f = set(d)
print(d)
# >>> {'名字','年龄'}

# 用大括号创建集合
aa = {1,2,3,(1,2,3),"123"}
print(aa)
# >>> {1,2,3,(1,2,3),'123'}
bb = {[10,20,30],[1,2,3]}
print(bb)
# >>> 报错
cc = {d}
print(cc)
# >>> 报错
# 字典/列表用大括号创建集合是不可行的

# 列表的去重
a1 = set([1,2,1,1,1,1,1])
print(a1)
# >>> {1,2}
# 元组的去重
a2 = set((1,1,1,1,1))
print(a2)
# >>> {1}
# 字典的去重
a3 = {
    "名字":"aa",
    "名字":"aa"
}
ff = set(a3)
print(ff)
# >>> {'名字'}
a4 = {
    "名字":"aa",
    "名字":"bb"
}
ff1 = set(a4)
print(ff1)
# >>> {'名字'}
# 字典去重针对的是键
zz = set("1211111")
print(zz)
# >>> {'2','1'}
abc = {1,2,1,1,"1111111",(1,1,111)}
print(abc)
# >>> {1,2,"1111111",(1,1,111)}
# 去重的话用set()更方便，用大括号有局限

集合添加元素的方法&合并集合

"""
集合添加元素的方法：
	1、add()：往集合中添加元素		数字/字符串/元组
	2、update()：update可以将集合合并
"""
a = {1,2,3}
a.add(6)
print(a)
# >>> {1,2,3,6}
# 集合中添加相同元素，不变
a.add("aa")
print(a)
# >>> {1,2,3,'aa'}
a.add((1,2,3))
print(a)
# >>> {1,2,3,(1,2,3)}
b = {"w","b","a"}
a.update(b)
print(a)
# >>> {1,2,3,'a','w','b'}
# 集合的排列是随机排列

集合删除元素的方法

"""
集合删除元素的方法：
	1、remove:
		使用remove删除集合中的元素，如果有直接删除，如果没有则程序会报错
	2、pop:
		使用pop删除是随机删除集合中的元素，如果集合没有元素程序报错
	3、discard:
		使用discard删除，如果元素存在直接删除，如果元素不存在不做任何操作
"""
# remove
a = {"python","学","mm"}
a.remove("学")
print(a)
# >>> {'python','mm'}
a.remove("123")
print(a)
# >>> 报错，在集合中不存在

# pop
a.pop()
print(a)
# >>> {'python','学'}
# 随机删除，结果不一定

# discard
a.discard("学")
print(a)
# >>> {'mm','python'}
a.discard("123")
print(a)
# >>> {'python','学','mm'}
# 与remove最大的区别在于：当删除集合中不存在的元素时，它不会报错，而是直接输出原来的集合a

集合的交集&并集

"""
集合的交集和并集：
	1、交集
		使用"&"符号连接多个集合，得到相同的元素
	2、并集
		使用"|"符号连接多个集合，得到集合中的全部数据
"""
s1 = {1,2,3,5}
s2 = {1,2,6,7}
s3 = s1 & s2
print(s3)
# >>> {1,2}
s4 = s1 | s2
print(s4)
# >>> {1,2,3,5,6,7}
# 由于2在两个集合中都有，耳机和本身是要去重的，所以s4中只有一个2

创建字典&空字典

"""
字典是一种映射类型，它的元素是键值对，字典的键必须为不可变类型，且不能重复，键可以是任意不可变类型(元组/字符串/数字)
1、字典的创建方式
	1)直接用"{}"
	2)使用dict()			dict((元组[列表]))
2、空字典
"""
a = {
    "姓名":"aa",
    "年龄":18,
    1:11,
    (1,2,3):"123"
}
print(a)
# >>> {'姓名':'aa','年龄':18,1:11,(1,2,3):'123'}

b = dict((["年龄","18"],["名字","aa"]))
print(b)
# >>> {'年龄','18','名字':'aa'}

c = {}
# 直接写大括号是字典,空字典

d = set()
# 表达空集合用set()

字典的增删改查的操作

d = {"名字":"aa","年龄":18}
# 增加
d["技能"] = "python技能"
print(d)
# >>> {'名字':'aa','年龄':18,'技能':'python技能'}

# 删除
del d["技能"]
print(d)
# >>> {'名字':'aa','年龄':18}

# 修改
d["名字"] = "bb"
print(d)
# >>> {'名字':'bb','年龄':18}

# 查询
print(d["年龄"])
# >>> 18

字典的操作方法–get&keys

"""
1、get函数：
	用于从字典获取指定键的值。在get函数中可以设置默认值，当get函数没有获取到对应键时，get函数会将默认值返回
2、keys函数：
	keys函数将以列表的形式返回字典中的所有键
"""
d = {
    "名字":"aa",
    "年龄":18
}

# get()
r = d.get("名字")
print(r)
# >>> aa
r1 = d.get("wer")
print(r1)
# >>> None
r2 = d.get("wer","ptyhon")
print(r2)
# >>> python

# keys()
print(d.keys())
# >>> dict_keys(['名字','年龄'])
f = {
    "名字":"aa",
    "年龄":18,
    "技能":{
        "技能1":"python",
        "技能2":"java"
    }
}
print(f.keys())
# >>> dict_keys(['名字','年龄','技能'])

字典的操作方法–items&values

"""
1、items函数：
	将以列表的形式返回字典中的所有键值对
2、values函数：
	将以列表的形式返回字典中的所有值
"""
d = {
    "name":"aa",
    "age":18
}
r = d.items()
print(r)
# >>> dict_items([('name','aa'),('age',18)])
r1 = d.values()
print(r1)
# >>> dict_values(['aa',18])

字典的操作方法–clear

"""
1、clear函数：
	用于将字典清空
1、copy函数：
	用于创建字典的副本，修改原字典对象，不会影响其副本
"""
d = {
    "name":"aa",
    "age":18
}
d.clear()
print(d)
# >>> {}
print(len(d))
# >>> 0
d1 = d.copy()
del d["name"]
print(d)
# >>> {'age':18}
print(d1)
# >>> {'name':'aa','age':18}

字典的操作方法–fromkeys&pop

"""
1、fromkeys函数：
	用于创建一个新的字典，
	第一个参数是一个序列(列表/元组/集合)，用于作为字典的键。
	第二个参数可以是任何数据类型，作为每个键的值。
2、pop函数：
	用于从字典中移除指定键，并返回该键所对应的值
"""
d = {}
d1 = d.fromkeys(("name","age"),(1,18))
print(d)
# >>> {}
print(d1)
# >>> {'name':(1,18),'age':(1,18)}
s = {
    "name":"aa",
    "age":18
}
r = s.pop('name')
print(s)
# >>> {'age':18}
print(r)
# >>> aa

字典的操作方法–popitem&setdefault

"""
1、popitem函数：
	用于从字典中删除最后一项，并以元组的形式返回该项所对应的键和值
2、setdefault函数：
	用于设置键的默认值，
	若在字典中该键已经存在，则忽略设置；若不存在，则添加该键和值
	d.setdefault(键,值)
"""
d = {
    "name":"aa",
    "age":18
}
r = d.popitem()
print(d)
# >>> {'name':'aa'}
print(r)
# >>> {'age':18}

d2 = {
    "name":"aa",
    "age":18
}
d2.setdefault("wer":"python")
print(d2)
# >>> {'name':'aa','age':18,'wer':'python'}
d2.setdefault("name":"python")
print(d2)
# >>> {'name':'aa','age':18}

d3 = {
    "name":"aa",
    "name":"bb"
}
print(d3)
# >>> {'name':'bb'}
# 键重复的话会进行覆盖，最后保留最后的一个键和值

字典的操作方法–update函数

"""
update函数：
	用于将字典2的值更新到字典1
	若字典2的键在字典1已经存在，则对字典1进行修改。
	若不存在，则对字典1进行添加。
"""
d1 = {
    "name":"aa"
}
d2 = {
    "name":"bb"
}
d1.update(d2)
print(d1)
# >>> {'name':'bb'}

d3 = {
    "name":"aa"
}
d4 = {
    "age":18
}
d3.update(d4)
print(d3)
# >>> {'name':'aa','age':18}

成员检测in&not in

"""
成员检测与标识号检测
	使用"in"和"not in"运算符来判断某个对象是否为序列的成员
in:判断对象是否在序列(列表/字符串/元组/字典)中，如果是则返回True
not in:判断对象是否不在序列中，如果是则返回True
"""
print("4" in "1234")
# >>> True
print(1 in (1,2,3,4))
# >>> True
ptint(1 in [1,2,3])
# >>> True
print("名字" in {"名字":"aa"})
# >>> True
print("aa" in {"名字":"aa"})
# >>> False
# 字典判断的是键而不是值
print("6" not in "1234")
# >>> True

判断某两个对象是否相同is&is not

"""
判断某两个对象是否相同，则是用is和is not运算符
	is(是)判断对象是否相同
	is not(不是)判断对象是否不相同
	数字/字符串/元组	都是不可变的数据类型	表面一样	完全一样
	列表/字典/集合	都是可变的数据类型	表面一样	其实不一样	其实不是同一个对象
"""
a = "mm"
b = "python"
print(a is b)
# >>> False
print(a is not b)
# >>> True
c = "111"
d = "111"
print(c is d)
# >>> True
f = [1]
g = [1]
print(f is g)
# >>> False
aa = {"name":"cc"}
zz = {"name":"bb"}
print(aa is zz)
# >>> False
ee = (1,2,3)
kk = (1,2,3)
print(ee is kk)
# >>> True
w = {1,2,3}
z = {1,2,3}
print(w is z)
# >>> False

python的类型转换–自动类型转换

"""
1、字符串类型 String
2、数字类型 Number
	整型 int
	浮点型 float
	布尔类型 Bool
3、表类型 List
4、元组类型 Tuole
5、字典类型 Dictionary
6、集合类型 Set
由于不同的数据类型之间是不能进行运算的，所以我们需要数据类型转换。Python中的数据类型转换有两种：
	1、一种是自动类型转换，即Python在计算中会自动地将不同类型的数据转换为同类型数据来进行计算。
	2、另一种是强制类型转换，即需要我们基于不同的开发需求，强制地将一个数据类型转换为另一个数据类型。
"""

python数据检测方法–type()

"""
1、检测数据类型的方法：
	type();
2、强制类型转换：
	str():可以把其他类型数据转换为字符串类型
	注意：所有类型都可以转化为字符串类型
"""
a = "123"
b = 123
c = [1,2,3]
d = (1,2,3)
e = {1,2,3}
f = {
    "name":"小明",
    "age":18
}
g = True
h = 3.14
print(type(a))
# >>> <class 'str'>
print(type(b))
# >>> <class 'int'>
print(type(c))
# >>> <class 'list'>
print(type(d))
# >>> <class 'tuple'> tuple : 元组
print(type(e))
# >>> <class 'set'> set : 集合
print(type(f))
# >>> <class 'dict'>  dict : 字典
print(type(g))
# >>> <class 'bool'> bool :布尔类型
print(type(h))
# >>> <class 'float'>
# 可以在type里面直接写数据

python的强制数据类型转换–str()

"""
str():可以把其他类型数据转换为字符串类型
	注意：所有类型都可以转化为字符串类型
"""
a = "123"
b = 123
res_b = str(b)
print(res_b)
# >>> 123
print(type(res_b))
# >>> <class 'str'>
c = [1,2,3]
d = (1,2,3)
e = {1,2,3}
f = {
    "name":"小明",
    "age":18
}
g = True
res_g = str(g)
print(res_g,type(res_g))
# >>> True <class 'str'>
print()
h = 3.14

python的强制数据类型转换–int()&float()

"""
int():可以把其他类型数据转化为整型
float():可以把其他类型的数据转化为浮点型
注意：
	数字类型之间可以相互转换
	只有字符串可以转换为数字类型
	并且字符串中的元素必须为纯数字，否则无法转换
		字符串中前面有负号是可以的，但不能有点号
"""
a = 123
r_a = float(a)
print(r_a)
# >>> 123.0
b = 3.14
r_b = int(b)
print(r_b)
# >>> 3
# 去掉的是小数点，不遵循四舍五入
# 布尔值也是数字
c = True
r_c = int(c)
print(r_c)
# >>> 1
e = "345"
r_e = int(e)
print(r_e,type(r_e))
# >>> 345 <class 'int'>

python的强制数据类型转换–bool()

"""
其他类型转数字类型中有一个特殊情况，就是其他类型转布尔类型
bool():可以把其他类型转为True或False
	1、容器类型转布尔类型：
		容器类型数据：字符串，列表，元组，字典，集合
		非容器类型数据：数字类型，布尔类型
		容器中为空-->False
		容器中有元素-->True
	2、数字类型转布尔类型：
		int类型中，0为False，其他为真
		float类型中，0.0为False，其他为真
"""
a = "" # 空字符串
b = [] # 空列表
c = () # 空元组
d = {} # 空字典
e = set() # 空集合
print(bool(a))
# >>> False
# 其他相同
bb = [1,2,3]
print(bool(bb))
# >>> True

python的强制数据类型转换–list()

"""
list():
	1、数字类型是非容器类型，不能转换为列表
	2、字符串转列表时，会把字符串中的每一个字符当作列表的元素
	3、元组转列表时，会把元组中的每一个字符当作列表的元素
	4、字典转列表时，只保留字典中的键
	5、集合转列表时，结果是无序的，因为集合本身就是无序的
"""
b = "abcd123"
print(list(b))
# >>> ['a','b','c','d','1','2','3']
c = (1,2,3,"123")
print(list(c))
# >>> [1,2,3,'123']
d = {
    "name":"11",
    0:1,
    (1,2,3):18
}
r = list(d)
print(r)
# >>> ['name',0,(1,2,3)]
e = {1,2,3,4,"a","wo"}
r_e = list(e)
print(r_e)
# >>> [1,2,3,4,'wo','a']

python的强制数据类型转换–turple()

"""
tuple():其他类型数据转元组类型与其他类型数据转列表类型的规则相同。
	1、数字类型是非容器类型，不能转换为元组
	2、字符串转元组时，会把字符串中的每一个字符当作元组的元素
	3、列表转元组时，会把列表中的每一个字符当作元组的元素
	4、字典转元组时，只保留字典中的键
	5、集合转元组时，结果是无序的，因为集合本身就是无序的
"""

python的强制数据类型转换–set()

"""
set():其他数据类型转集合类型
	1、数字类型是非容器类型，不能转换为集合
	2、字符串转集合时，结果是无序的
	3、列表转集合时，结果是无序的
	4、元组转集合时，结果是无序的
	5、字典转集合时，只保留字典的键，结果是无序的
"""

python的强制数据类型转换–dict()

"""
dict():其他类型转字典类型
	1、数字类型是非容器类型，不能转换为字典
	2、字符串不能转字典类型，因为字符串不能生成二级容器
	3、列表类型转字典类型，列表必须为等长二级容器，子容器中的元素个数必须为2
	4、元组类型转字典类型，列表必须为等长二级容器，子容器中的元素个数必须为2
	5、集合不能转字典类型
"""
c = [1,2,3,"我","a"]
# 会报错，因为该列表不是等长二级容器
cc = [[1,2],["a","b"],["名字","aa"]]
print(dict(cc))
# >>> {1:2,'a':'b','名字':'aa'}
# 元组类似

python用来判断一个对象是否是一个已知的类型isinstance()

"""
isinstance():用来判断一个对象是否是一个已知的的类型
	isinstance():函数的返回值是布尔类型，
	若对象的类型是已知的类型，那么酒店返回True，否则返回False
语法如下：
	isinstance(对象,对象类型)
	int(整数)	float(浮点数)	bool(布尔值)	str(字符串)
    list(列表)	turple(元组)	set(集合)	dict(字典)
"""
a = 123
print(isinstance(a,int))
# >>> True
print(isinstance(a,(float,int,str)))
# 其中有一个满足就为True
# (float,int,str)为一个元组
# >>> True
b = 123.68
c = True
d = "abc123我爱你"

if语句

"""
if...elif...else...分支语句
条件必须是真值，才能运行if里面的语句
if语句是可以单独存在的
if elif(无数个) else
if else
"""
if 3 > 2:
    print("你好！")
elif 4 > 1:
    print("123")
# >>> 你好！
# 缩进必须存在

for循环

"""
for:
	for循环用来遍历序列
	通过不使用下标的方式来实现对序列中的每一个元素的访问
	列表/元组/字符串/字典/集合
	
	遍历数字 rang()
	
	python的for循环语句：
		1、遍历字典的 键 和 值	d.items()
		2、rang函数的步长
"""
for i in [1,2,3]:
    print(i)
# 1
# 2
# 3
# 列表/元组/字符串/字典/集合 相同，字典只会提取其中的键
for i in rang(0,10):
    print(i)
# 0
# 1
# 2
# 3
# 4
# 5
# 6
# 7
# 8
# 9

d = {
    "名字":"aa",
    "年龄":18
}
for a in d:
    print(a)
# 名字
# 年龄

for s in d.items():
    print(s)
# ('名字','aa')
# ('年龄',18)

for i in rang(0,6,2):
    print(i)
# 0
# 2
# 4

"""
python的双层for循环	if判断
isinstance() 用来判断一个对象是否是一个已知的类型
"""
a = [1,2,3,[10,20,30],[50,60,70]]

for i in a:
    print(i)
    # 判断，满足条件	是否是列表
# 1
# 2
# 3
# [10,20,30]
# [50,60,70]

	if isinstance(i,list):
        # 提取工作	提取列表中的数据
        for x in i:
            print(x)
# 10
# 20
# 30
# 50
# 60
# 70

while循环

"""
可以配合else使用
"""

c = 0
while c < 6:
    print(c)
    c += 1
# 0
# 1
# 2
# 3
# 4
# 5
else:
    print("c变量的值已经为6，不满足c<6的条件了！")
# c变量的值已经为6，不满足c<6的条件了！

break&continue

"""
break	语句可以跳出for和while的循环体。
continue	语句被用来跳过当前循环块中的剩余语句，然后继续进行下一轮循环。
"""

pass语句

"""
pass	 是空语句，是为了保持程序结构的完整性。
它用于那些语法上必须要有什么语句，但程序生命也不做的场合。
"""
for i in rang(0,10):
# 运行时报错
for i in rang(0,10):
    pass
# 运行时不会报错，再写其他程序时也不会有什么影响

学完这个的话就可以学习函数了

大不了_自己学
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python基础知识点总结
学Python的小白！
08-25 7万+
本文包括python基本知识：简单数据结构，数据结构类型（可变：列表，字典，集合，不可变：数值类型，字符串，元组），分支循环和控制流程，类和函数，文件处理和异常等等。
Python基础学习笔记
03-21
1.Python基础 1.1使用基础 1.2PIP使用 1.3内置函数/变量/模块 1.4代码输入基础知识细节 1.5列表 1.6元组 1.7字典 1.8集合 1.9公共方法 1.10推导式 1.11函数 1.12文件操作 1.13语法错误与异常处理 1.14生成器 1.15...
Python [::-1]的简单理解与用法
xiongxyowo的博客
09-25 2万+
既然涉及到三维，那就可以拓展到图片了。比方说，使用cv2.imread读到的图片是存储在尺寸为(H, W, C)的ndarray里的。步长是正数的话，[a:b]是从a到b，往右读取，b应该比a大；自然而然的，如果不指定a，b，那么处理的范围是整个列表；步长为-1，表示整个列表从右往左读取，即翻转数组。这一结果的本质是，切片本身只在数组的第0维去操作，而二维数组的的0维是行，因此会把所有行给逆序。那么这个东西的原理是什么呢？多一个冒号的话，新冒号后面的数字表什么呢？从结果上来看，[::-1]的作用是。
python基础知识笔记
qq_47541315的博客
10-01 3万+
python基础语法知识总结笔记，视频看的是b站的黑马程序员8天学会Python基础。
Python 基础知识学习笔记——NumPy
Neverlevsun的博客
11-11 873
Python 基础知识学习笔记——NumPy学习
Python 基础（一）：入门必备知识
热门推荐
Python小二
10-30 105万+
Python 入门必备知识，你都掌握了吗？
一篇贼全的Python基础学习笔记
yueliangmua的博客
07-26 5468
Python的基础知识总结，自学后整理。
小甲鱼零基础入门学习python笔记
qq_32809093的博客
12-15 13万+
小甲鱼老师零基础入门学习Python全套资料百度云(包括小甲鱼零基础入门学习Python全套视频+全套源码+全套PPT课件+全套课后题及Python常用工具包链接、电子书籍等）请往我的资源（https://download.csdn.net/download/qq_32809093/11528609）查看 000 愉快的开始 python跨平台。 应用范围：操作系统、WEB、3D动画、企业应用...
Python学习笔记
qq_61524266的博客
04-01 6647
python的个人总结
Python学习笔记-PyQt基本知识
向往的是：佛祖堂前的鱼，静静听禅。
12-21 7968
记述PyQt的相关基本知识。
python库streamlit学习笔记
python收藏家的博客
02-24 1万+
Streamlit学习笔记
Python基础教程学习笔记 第一章 基础知识
09-03
主要介绍了Python基础教程学习笔记 第一章 基础知识 ,需要的朋友可以参考下
python的基础知识笔记
01-16
python的基础知识笔记，适合初学者学习，包含了基本语法的使用等，可以配合其他网课使用，建议使用typora打开，如果学习了其他的语言，那学习python基础并不是什么难事。
python基础学习笔记整理
11-08
适合python入门学习，笔记含有示例代码，贴入工具中可执行查看效果。 1、环境准备 2、基础知识 2.1、语法 2.1.1、变量和数据类型 2.1.2、控制流程if for while 2.1.3、函数实例 2.1.4、购物车 2.1.5、字符编码与文件...
【 书生·浦语大模型实战营】作业（六）：Lagent & AgentLego 智能体应用搭建
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
05-03 1370
本篇笔记内容主要为 【书生·浦语大模型实战营】作业（六）：Lagent & AgentLego 智能体应用搭建智能体的作业 ，主要对智能体应用理论部分及具体搭建流程详细介绍，并分别进行实战应用及可视化展示，欢迎大家交流学习！
第五节课《LMDeploy 量化部署 LLM 实践》
最新发布
fanre的专栏
05-06 595
PDF链接：https://pan.baidu.com/s/1JFtvBWgEGFWJq8pHafvIUg?pwd=6666提取码：6666。
Kubernetes基础(二十九)-资源预留
sre救赎之路
05-05 913
如果还设置了对应的 --system-reserved-cgroup 和 --kube-reserved-cgroup参数，Pod能实际使用的资源上限不会改变（即kubepods.limit_in_bytes不变），但系统进程与kube进程也会受到资源上限的限制。比如某个节点的内存的allocatable为10Gi，有三个Pod（requests.memory=3Gi）已经调度到该节点上，那么第4个Pod就无法调度到该节点上，即使该Node上的空闲内存大于3Gi。
Python 发送钉钉消息（markdown格式）
qq_43773590的博客
04-30 695
【代码】Python 发送钉钉消息（markdown格式）
when the starting window is added to the diaplay?
我的博客
05-05 255
when the starting window is added to the diaplay?

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大不了_自己学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值