首页 > 编程语言 >python知识点（1）

python知识点（1）

时间：2024-03-16 10:59:24浏览次数：24  
标签：知识点 set name python list len 列表 print

python知识点

基础数据类型

  • 整形 int
  • 浮点型 float
  • 布尔型 bool
  • 字符型 string

整形 int

: int 是一种提示 没有任何作用 是编辑器提供的和解释器无关

type() 查看变量的数据类型

age: float = 18
print(age, type(age))
#输出结果
18 <class 'int'>
进制转换

37 -> 转换二进制 32 + 4 + 1 2^5 2^2 2^0 0010 0101
0010 0100 -> 二进制转十进制 02^0 + 02^1 + 12^2
二进制转十六进制 0000 0 -> 15
十六进制转十进制 0xffff 1111 1111 1111 1111 1516^0 + 15*16^1

基础数据类型转换

int类型可转化为float类型，bool类型，string类型

int 转 bool 只要int值不为0 结果就是true

浮点型 float

基础数据类型转换

float类型可转化为int类型，bool类型，string类型

float 转int 不会四舍五入 只保留整数位数字

float 转 bool 只要int值不为0 结果就是true

布尔类型 bool

基础数据类型转换

bool类型可转化为int类型，float类型，string类型

字符串 string

基础数据类型转换

string类型可转化为int类型，float类型，bool类型

str 转 int 只有整数类型的字符串能转换为整型

str 转 float 只要是数字字符串都能转换为浮点型

str 转 bool 只有空字符串是false 其他全是true

字符串编码解码
food = '烤竹鼠'
food_utf8 = food.encode("utf-8")
print(food_utf8, type(food_utf8))
food_gbk = food.encode("gbk")
print(food_gbk, type(food_gbk))

# 解码
# print(food_gbk.decode("utf-8"))
print(food_gbk.decode("gbk"))
print(b'\xe7\xab\xb9\xe9\xbc\xa0'.decode("utf-8"))

gbk编码占两个字节 utf-8编码占三个字节

格式化字符串
msg = "尊敬的xxx，您本月话费消费xx元，您的账户余额为xx元，打败了全国xx%的用户，如余额不足请及时缴费。xxxx年xx月xx日。"

几种方法

# 占位符  %d 整数 %s 字符串 %f 浮点型
msg_new = """尊敬的%s，您本月话费消费%.2f元，您的账户余额为%.2f元，
打败了全国%.2f%%的用户，如余额不足请及时缴费。%d年%02d月%02d日。"""
print(msg_new % (name, cost, balance, percent, year, month, day))

msg_new = """尊敬的{}，您本月话费消费{:.2f}元，您的账户余额为{:.2f}元，
打败了全国{:.2f}%的用户，如余额不足请及时缴费。{}年{:02d}月{:02d}日。"""
print(msg_new.format(name, cost, balance, percent, year, month, day))

msg_new = """尊敬的{n}，您本月话费消费{c:.2f}元，您的账户余额为{b:.2f}元，
打败了全国{p:.2f}%的用户，如余额不足请及时缴费。{y}年{m:02d}月{d:02d}日。"""
print(msg_new.format(n=name, c=cost, b=balance, d=day, p=percent, y=year, m=month))

# f-string
msg_new = f"""尊敬的{name}，您本月话费消费{cost:.2f}元，您的账户余额为{balance:.2f}元，
打败了全国{percent:.2f}%的用户，如余额不足请及时缴费。{year}年{month:02d}月{day:02d}日。"""

字符串输出的时候有时候要用到转义字符\和%，其中%专门转义%

字符串方法
# 去除两端空格 strip()  lstrip rstrip ##去除左/右空格
print(name.strip())
# replace 函数前面的元素被后面的替换
print(name.replace('A', 'a'))
# 切分所有的数据 默认切分空格 后面是切分次数 切分后放进列表里
print(name.split('-', 1))
# count 数字符的个数 前面是查找内容 后面是起始位置和终止位置 索引取值的方式基本都是左闭右开 [ )
print(name.count("a", 0, 1))
# index 查看字符串的索引  一般第一个   
print(name.index("翟", 3))
# isdigit 检测这个字符串是否为数字
print("12a".isdigit())
# islower 检测是否为小写字母
print('abcA'.islower())
# isupper 检测是否为小写字母
print('Aa'.isupper())
# lower upper 大小写转换
print("A".lower())
print("a".upper())
# startwith 以什么开头
print(name.startswith("a"))
# 检测一个子串是否在一个大字符串里面 in \ not in
print("b" in name)
# 切片  [start:stop:step] start + step => stop
print(name[1:7:2])
# 字符串反转
print(name[::-1])
# 长度
print(len(name))

变量

常量

python里没有常量
一般常量都用大写字母

PI = 3.14
变量规范

大小写字母 数字 下划线 构成 但是不能是数字开头
能不能是关键字（保留字）

关键字

[‘False’, ‘None’, ‘True’, ‘and’, ‘as’, ‘assert’, ‘async’, ‘await’,
‘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’]

运算符

# 算术运算符
print(1 + 2)
print(1 - 2)
print(1 * 2)
print(1 / 2)
print(9 % 2)
print(3 ** 3)
print(5 // 2)  # 向下取整

# 比较运算符
a, b = 10, 20
print(a == b)
print(a != b)
print(a > b)
print(a < b)
print(a <= b)
print(a >= b)

# 赋值运算符
# =
a = 10
a += 1  # a = a + 10
a -= 1
a *= 2  # a = a * 2

# 逻辑运算符  and or not
a, b = 10, 20
print(a and b)
print(a or b)
print(not a)

# 位运算，将数字转化为二进制数进行计算
print(a & b)
# 与运算  上下两位结果都是1 结果为1 否则为0
print(a | b)
# 或运算  上下两位结果都是0 结果为0 否则为1
print(a ^ b)
# 或运算  上下两位结果相异 结果为1 否则为0

# 取反 0，1互换
print(~a)
# 整体左移 低位用0补上
print(a << 2)
# 整体右移 高位用0补上
print(a >> 2)

if判断

if判断结构

# if—else结构
if (判断语句):
    (执行操作)
else:
    (执行操作)

# if-elif结构
if (判断语句):
    (执行操作)
elif(判断语句):
    (执行操作)
elif(判断语句):
	(执行操作)
else:
    (执行操作)

if-elif 结构中要注意 if 和 elif 的定义域

三元表达式

# 一般结构
a = 5
if a % 5 == 0:
    print(1)
else:
    print(0)
# 三元运算符 True if else False
print(1) if a % 5 == 0 else print(0)

循环

for循环

for循环结构
# range 只给stop 值 区间为 [0,stop)
for i in range(10):
    print(i)
# 区间 [start,stop)
for i in range(11, 15):
    print(i)
# 区间 [start,stop) 步长是2
for i in range(20, 30, 2):
    print(i)
for循环遍历可迭代的序列
name = 'Cordial'
len(name)
for i in range(len(name)):
    print(name[i])

可遍历列表 list，元组 tuple，字符串 string

用for循环完成的冒泡排序
for i in range(len(s) - 1):
    # 循环没有排好序的数据
    flag = True
    for j in range(len(s) - 1 - i):
        if s[j] > s[j + 1]:
            # tmp = s[j]
            # s[j] = s[j+1]
            # s[j+1] = tmp
            flag = False
            s[j], s[j + 1] = s[j + 1], s[j]
    if flag:
        break

标志位flag和break是为了提高效率，降低该算法的复杂度

for-else结构

# for else 循环正常跑完 就会执行else内的内容
# for else 结构中如果break 执行了 就不会执行else内的内容
for i in range(2, 10):
    for j in range(2, i):
        if i % j == 0:
            print(f"{i} is not a prime number")
            print(f"{i} = {j} * {i / j}")
            break
    else:
        print(f"{i} is a prime number")

while循环

while循环结构
i = 0
summ = 0
while i <= 100:
    summ += i
    i += 2
print(summ)

相对于for循环，while循环中得定义一个计算次数的标志，以免无法跳出循环

while循环里的一些用法
# break 强制终止循环
# continue 跳出本次循环
n = 0
summ = 0
while n <= 100:
    # 只计算十以内的偶数和
    if n > 10:
        break
    summ += n
    n += 2
print(summ)
编译没有错误死循环
# 死循环  一直卡在10这个数字不动
n = 0
summ = 0
while n <= 100:
    # 偶数和 但是不加十
    if n == 10:
        continue
    summ += n
    n += 2
print(summ)

这说明即使编译器没有报错，但是while循环仍有可能出现错误，这个死循环就是逻辑上的错误

列表 list

列表的性质

  • 有序 所以列表可以用循环进行遍历
  • 可变 所以可以对列表进行增删改查

同一个列表中尽量保持数据类型相同

List方法

# 增
# append 追加是直接追加内容 括号里是什么数据类型就增加什么数据类型 不做处理
list_a.append("a")
list_a.append(["b"])
# insert 指定索引位置增加
list_a.insert(3, ["a"])
# extend 将可迭代的数据 单个放进去 相当于循环append
list_a.extend("ab")
list_a.extend(["AB"])
	#结果
     ['a', 'b', 'AB']

# 删除
# pop 弹出 默认弹出最后一个元素
list_a.pop(-2)
# remove 指定元素删除
list_a.remove(1)
# 清空所有元素
list_a.clear()

# 改
# 直接查找元素 然后赋值
list_a[0] = 0.01

# 查
# index 查找值的索引位置
list_a.index(1.2)
# count 计算列表中值出现的次数
list_a.count(1)
# reverse 将列表进行反转
list_a.reverse()
# sort 将列表进行排序 只有同类型的才可以进行比较
num_list = [1, 2, 5, 6, 8, 3, 5, 7]
num_list.sort()

关于循环遍历list的补充

# 错误列子
li = ['ab', 'abc', "abe", 'c', 'cde', 'd', 'sd', 'ab']
for i in li:
    if i.startswith("a"):
        li.remove(i)
print(li)

	# 结果
    ['abc', 'c', 'cde', 'd', 'sd']

列表循环的时候不要去做删除的事情，因为删除后索引不变列表序列会变

列表生成式

# 一般结构
li = []
for i in range(1,11):
    li.append(f'{i} * {i}')
print(li)
# 列表生成式
# 一般是空列表append的时候使用这个方式
print([f'{i} * {i}' for i in range(1, 11)])

列表和字符串的转化

#字符串和list之间的转换
#列表转字符串
#join 方法把一个可迭代的内容转换成字符串 在中间加上你相加的内容
#可迭代的内的数据类型应该为字符串
li_a = ['S', 'A', 'C', 'W', 'Z']
print("".join(li_a))
	#结果
    "SACWZ"

浅拷贝和深拷贝的区别

浅拷贝和深拷贝格式
# 普通赋值
l2 = l1

# 浅拷贝
l2 = l1.copy()

# 深拷贝
# 深拷贝要导入一个内置的包copy
import copy
l2 = copy.deepcopy(l1)
区别
l1.append("e")

上述三种方式如果执行这种操作，结果会如下

['a', 'b', 'c', 'd', [1, 2], 'e']
['a', 'b', 'c', 'd', [1, 2]]
['a', 'b', 'c', 'd', [1, 2]]

而如果进行下述操作，结果又会不同

l1[4].append(4)

结果：

['a', 'b', 'c', 'd', [1, 2, 4], 'e']
['a', 'b', 'c', 'd', [1, 2, 4], 'e']
['a', 'b', 'c', 'd', [1, 2], 'e']

原因是

直接赋值的时候，L1将物理地址复制给了L2,而对L1进行操作之后，L2根据地址查找到的是L1已经进行过操作后的列表，所以值也会变

而浅/深拷贝是会复制L1的内容，并且重新创建一个地址对应这个内容，所以不受影响

但是如果对列表中的列表进行操作的话，浅拷贝复制创新的不完全，内部列表没办法新建地址，所以也会改变值

元组 tuple

元组的性质

  • 有序 也可以循环遍历操作
  • 不可变 里面的值不可以改变，所以元组方法较少

元组有特殊情况可以改变里面的值——元组包含列表的请况下

Tuple方法

# index 查找值的索引位置 前面是要查找的值 后面是起始位置和终止位置
tuple.index("1", 2, 5)
# count 计算元组中要查找的值出现的次数
tuple.count("a")

定义元组的方法

# 定义一个二元/多元组
tuple = ("a","b","v")
# 定义一个一元组
tuple_1 = ("a",)

字典 dict

字典的性质

  • 无序

  • key不可变 hash方法值找键的映射地址

  • 字典可变 意味着可以动态地添加、删除、修改键值对

字典的key不可以放任何可变的数据类型

Dict方法

# 查
# 查找值 直接字典名称+键
dict_score = {"m": 95, 'b': 75, 't': 85, 0: 333}
print(dict_score[0])
# get 通过key去取值 如果key不存在则返回none 最好使用get方法去获取值
print(dict_score.get("s"))

# 删
# pop 删除pop里key所指的键值对
print(dict_score.pop(0))
# popitem 随机删除一个键值对
dict_score.popitem()

# fromkeys 通过可迭代数据形成一个字典
print(dict_score.fromkeys("ab", 1))
	# 结果
    {'a': 1, 'b': 1}

# 字典的遍历方式 items方法
for k, v in dict_score.items():
    print(k, v)
    
# 单独查找键或值
dict_score.keys()
dict_score.values()

# 查找键/值里是否含有某个元素
dict_b = {"m": "n"}
if "m" in dict_b.keys():
    print("yes")

popitem使用时，因为字典是无序的，所以会随机删除一个键值对

关于dict的补充

dic_a = {"a": "b", "c": "d", "e": "f"}
for k, v in dic_a.items():
    print(k, v)
    dic_a.pop(k)

字典循环的时候也不要去做删除的事情 字典直接就报错了

# 字典 字典如果有重复的键  ，值一般以后面的为准 相当于后来的值覆盖了前面的值
# 字典的新增 直接给一个从来没有出现过的键 然后给一个值
# 如果是已经存在的key则覆盖之前的值
dic_a = {1: 2, True: 3, 2: 3, 2: "3"}
dic_a[4] = "4"
print(dic_a)
	# 结果
    {1: 3, 2: '3', 4: '4'}

dict和json相互转换

import json

# dict 与 json之间的转换
dict_a = {"1": 2, "3": 4}

# 字典转换为json  dump()方法
json_str = json.dumps(dict_a)
# json大字符串转字典  loads()方法
json_dict = json.loads(json_str)

字典生成式

# 一般结构
dic_a = {}
for i in "ABC":
    dic_a[i] = i.lower()
print(dic_a)
# 字典生成式
print({i: i.lower() for i in "ABC"})

集合

  • 不可变
  • 不重复 可用于去重
  • 无序
set_a = {1, 2, "True", True, 1.0, ("c", "d")}

相当于只存储了字典中的键 只是没有值 依然遵守键的规则

set方法

# 去重
list_a = ['a', 'b', "c", "d", "a"]
print(list(set(list_a)))
	# 结果
    ['d', 'a', 'c', 'b']

# 创建一个空的集合
# 只有一个大括号会被识别成字典
set_b = {}
set_c = set()  

# pop 弹出一个键 随机
set_num1.pop()

# remove 删除一个键  如果没有这个键就会报错
set_num1.remove(8)

# discard 删除一个键  如果没有这个键删除不会报错
set_num1.discard(8)

# add 添加一个新键
# 如果键已存在 则相当于没有添加
set_num1.add(8)

# difference 去除原集合中和集合2中相同的部分
set_num1.difference(set_num2)
# difference_update 从这个集合中删除和另外一个集合中相同的元素  在原集合上操作
set_num1.difference_update(set_num2)
# intersection 交集
set_num1.intersection(set_num2)
# isdisjoint 检测两个集合是否具有相同的元素
set_num1.isdisjoint({8, 9})
# issubset issuperset  检测是否为子集或者父集
set_num1.issuperset(set_num3)
# union 并集
set_num1.union(set_num2)
# symmetric_difference 并集 - 交集
set_num1.symmetric_difference(set_num2)

如果是对原列表、集合进行操作，返回值一般为空，不能直接print

遍历数据容器

遍历列表

list_a = ["a", "b", "c", "d", "e", "f"]
# 直接遍历内部值
for i in list_a:
    print(i)

# 遍历索引
for i in range(len(list_a)):
    print(list_a[i])
    
# for循环中使用enumerate方法遍历索引和列表里的数据
for ind, val in enumerate(list_a):
    print(ind, val)

遍历元组

tuple_a = ("h", "i", "j", "k", "l", "m", "n")
# 直接遍历内部值
for i in tuple_a:
    print(i, end="\t")

# 遍历索引    
for i in range(len(tuple_a)):
    print(tuple_a[i], end="\t")

# for循环中使用enumerate方法遍历索引和列表里的数据
for ind, val in enumerate(tuple_a):
    print(ind, val, end="\t")

同时遍历元组和列表

# 普通循环方法
max_len = 0
if len(list_a) > len(tuple_a):
    max_len = len(list_a)
else:
    max_len = len(tuple_a)
for i in range(max_len):
    if i > len(list_a) or i > len(tuple_a):
        print(list_a[i], tuple_a[i])

# zip方法
for i, j in zip(list_a, tuple_a):
    print(i, j)

函数

参数

函数中参数位置 ： 必选参数 默认参数 可变参数 命名关键字参数 关键字参数

必选参数/位置参数
# def 定义函数的关键字 circle_area 函数名
# 参数 需要传进来的值
def circle_area(r: float):
    """
    :param r: 半径
    :return: ⚪的面积
    """
    # 函数用于计算⚪的面积
    s = PI * r * r
    # print(s)
    return s

函数的参数
r 是必选参数\位置参数 必须传入参数
Pi 默认参数 不传参数时以默认值计算 传参是以给定值计算

可变参数
def get_num_avg2(*args):
    mean_num2 = sum(args) / len(args)
    print(mean_num2)

可变参数 接受任意长度的数据 存放如一个元组中

命名关键字参数
def get_student_info3(name, age, *, addr, height):
    print(f"学生姓名是{name}，年龄为{age},住址为{addr},身高{height}")

命名关键字参数 接受一个字典形式的参数 传参的时候记得给一个名字

关键字参数
def get_student_info3(name, age, **kw):
    print(f"学生姓名是{name}，年龄为{age},其他为{kw})

关键字参数之前必须加两个**

一些基础的内置函数

匿名函数 lambda

# 一般的简单加密算法
def num_plus(x):
    return x + 1
print(num_plus(1))

#lambda函数
f = lambda x: x + 1
print(f(2))

map函数

def num_plus(x):
    return x + 1
li = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# map方法 在函数和可迭代的序列之间加一个映射
print(list(map(num_plus, li)))
	#	结果
    [2, 3, 4, 5, 6, 7, 8, 9, 10]

reduce规约

from functools import reduce

print(reduce(lambda x, y: x + y, li))
# 字符串反转
strs = 'abcdefghijklmnopqrstuvwxyz'
print(reduce(lambda x, y: y + x, strs))

操作说明

查看函数提示

ctrl + p

快速规范代码

ctrl+alt+l

标签：知识点,set,name,python,list,len,列表,print
From： https://blog.csdn.net/Wy_0301/article/details/136682145

相关文章

  • 利用Python来计算微信群内捐款总额（正则匹配提取数字），并利用pandas把数据存入到excel中
    概述    这是一个现实中实际的案例，用到的知识也都是非常基础的东西，刚学完Python基础知识的可以用来练手。        情况是这样的，前两天村里有人突发重病，住进了重症监护室，这个人是家里上有老、下有小，家庭条件比较困难，因此村里组织号召大家捐款，村里人也积极友爱......
  • 梯度下降算法原理 用python实现
    1.介绍我们常常说阶梯要慢慢下，但是我们的计算机不这样认为，因为他们是人类智慧的结晶，我们已经知道了最优解，在某些方面，所以我们要找到最速梯度，这样梯度下降就被广泛运用。梯度下降（gradientdescent）在机器学习中应用十分的广泛，不论是在线性回归还是Logistic回归中，它的主要目......
  • 【笔记】Python爬虫之Xpath、BS4解析
    1、Bs4解析#安装bs4importrequestsfrombs4importBeautifulSoup#1url=""resp=requests.get(url)#2.将请求到的数据变成BeautifulSoup对象sp=BeautifulSoup(resp.text,'lxml')#↑加.text↑固定lxml#————————————————......
  • 【Python】什么是wsgi，uwsgi，uWSGI?
    WSGIWSGI(WebServerGatwayInterface)是一个python标准库，定义了web服务器和Python应用之间的接口。这个标准允许Web服务器（Apache或者nginx）将请求转发给Python应用（如Django或者Flask）然后将应用的响应返回给客户端。简单来说，WSGI充当了Web服务器和Python应用之间的桥梁......
  • python学习笔记-scarpy
    一、scrapy介绍Scrapy是一个为了爬取网站数据，提取结构性数据而编写的应用框架应用原理1、指定初始url 2、解析响应内容 -给调度器 -给item;pipeline;用于做格式化；持久化引擎(Scrapy)用来处理整个系统的数据流处理,触发事务(框架核心)调度器(Scheduler)用来接......
  • 深度学习入门：基于Python的理论与实践 笔记
    深度学习入门：基于Python的理论与实践笔记一，Python基础由于本人之前已经系统学习过Python，此处只总结有关深度学习的Python的库NumPy生成NumPy数组要生成NumPy数组，需要使用np.array()方法。np.array()接收Python列表作为参数，生成NumPy数组（numpy.ndarray）>>>x=np.array......
  • 深度学习入门基于python的理论与实现-第四章神经网络的学习（个人向笔记）
    目录从数据中学习损失函数均方误差(MSE)交叉熵误差mini_batch学习mini_batch版交叉熵误差的实现从数据中学习神经网络的"学习"的学习是指从训练数据自动获取最有权重参数的过程。神经网络的特征就是可以从数据中学习即由数据自动决定权重参数的值。机器学习通常是认为确定一些......
  • 基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的火焰检测系统（Python+PySide6界面+训练代码）
    摘要：本研究详述了一种采用深度学习技术的火焰检测系统，该系统集成了最新的YOLOv8算法，并与YOLOv7、YOLOv6、YOLOv5等早期算法进行了性能评估对比。该系统能够在各种媒介——包括图像、视频文件、实时视频流及批量文件中——准确地识别火焰目标或着火点等。文章深入阐述了YOLOv8算法......
  • 基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的番茄成熟度检测系统（Python+PySide6界面+训练代码）
    摘要：开发番茄成熟度检测系统对于提高农业产量和食品加工效率具有重大意义。本篇博客详细介绍了如何利用深度学习构建一个番茄成熟度检测系统，并提供了完整的实现代码。该系统基于强大的YOLOv8算法，并结合了YOLOv7、YOLOv6、YOLOv5的对比，展示了不同模型间的性能指标如mAP、F1Score等......
  • 基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的行人车辆检测与计数（Python+PySide6界面+训练代码）
    摘要：开发行人车辆检测与计数系统对于提升城市交通管理和监控系统的效率至关重要。本篇博客详细介绍了如何利用深度学习构建一个行人车辆检测与计数系统，并提供了完整的实现代码。该系统基于强大的YOLOv8算法，并结合了YOLOv7、YOLOv6、YOLOv5的对比，给出了不同模型之间的性能指标如mAP......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99