首页 > 其他分享 >day01

day01

时间：2023-07-14 20:34:51浏览次数：37  
标签：__ 10 变量 对象 day01 引用 print

变量

变量的命名应该满足以下三个规范：
1.变量的命名应该能反映变量值所描述的状态，切记不要用中文
2.变量名可由字母、数字和下划线组成，但是不能以数字开头
3.关键字不能声明为变量名

以下为常见的几个变量名

['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield']

变量体的两种风格

驼峰体

AgeOfCyk = 25
print(AgeOfCyk)

下划线体

age_of_Cyk = 25
print(age_of_Cyk)

25

变量的三个特征

x = 10
print(x)  # 获取变量的变量值
print(id(x))  # 获取变量的id，可以理解成变量在内存中的地址
print(type(x))  # 获取变量的数据类型，下章会详细介绍数据类型

#在Python中，is是一个用于比较两个对象身份（identity）的运算符。具体而言，is运算符用于检查两个对象是否引用了内存中的相同位置。当使用is运算符进行比较时，它会检查对象的内存地址，如果两个对象引用了同一个内存地址，则返回True，否则返回False。

x = "Hello"
y = "Hello"
z = x
print(x is y)  # False，x和y引用了不同的内存地址
print(x is z)  # True，x和z引用了相同的内存地址
#在上面的示例中，x和y引用了不同的内存地址，因此x is y的结果是False。而x和z引用了相同的内存地址，所以x is z的结果是True。需要注意的是，is运算符用于比较对象的身份，而不是比较对象的值。如果你需要比较对象的值是否相等，应该使用==运算符。

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)  # True，a和b的值相等
print(a is b)  # False，a和b引用了不同的内存地址
#在上面的示例中，a和b引用了不同的内存地址，所以a is b的结果是False。但是它们的值是相等的，所以a == b的结果是True。

10
1906339584
<class 'int'>
True
True
True
False

x = 257
z = 257

print(x is z)  # False
#在Python中，整数对象在范围-5到256之间被缓存，以便在代码中的多个引用中共享相同的对象。这意味着对于位于此范围内的整数，它们的id()是相同的，因此is运算符会返回True。然而，对于超过此范围的整数，Python不会缓存对象，因此它们的id()将不同，is运算符会返回False。此时变量x和z都被赋值为257。根据上述规则，它们的is运算符结果将是False，因为257超过了缓存范围。因此，print(x is z)的输出将是False。

False

常量

python中没有使用语法强制定义常量

python的变量内存管理

变量存放

x = 25

如果我们在python中定义了一个变量x，如果我们没有用python解释器去运行该文件，那么x=25只是很普通的四个字符x、=、1、0,只有当python解释器运行这个文件的时候，字符才会进入内存，才会有变量这个概念，也就是说变量是存放在内存中的。

eg:现在想象我们在学校（电脑内存）里上课，学校每开一个班，学校都会开辟一个教室给这个班级上课用（存放变量值10），而班级的门牌号则是（变量名x）。也就是说，对于电脑内存这个大内存，每定义一个变量就会在这个大内存中开辟一个小空间，小空间内存放变量值10，然后内存给这个小空间一个变量名x（门牌号），x指向10。

垃圾回收机制

如果我们此时再加上另一段代码x = 11,大内存会开辟另外一个小空间存储变量11，把变量值绑定另一个门牌号x，但是由于之前有x，所以大内存会解除x与10的连接，让x与11连接。这个时候10由于没有了门牌号，所以成为了python眼中的垃圾，python就会处理这个垃圾，释放10的内存占用，这就是python的垃圾回收机制。而其他编程语言需要手动把10的内存占用释放掉。

引用计数

在Python中，可以通过sys模块的getrefcount函数获取指定对象的引用计数器的值

import sys

class A():
    def __init__(self):
        pass
        
a = A()
print(sys.getrefcount(a))

2

计数器增减条件

引用次数+1的条件
  • 对象被创建，如A()。
  • 对象被引用，如a=A()。
  • 对象作为函数的参数，如func(a)。
  • 对象作为容器的元素，如arr=[a,a]。
引用次数-1的条件
  • 对象被显式销毁，如del a。
  • 变量重新赋予新的对象，例如a=0。
  • 对象离开它的作用域，如func函数执行完毕时，func函数中的局部变量（全局变量不会）。
  • 对象所在的容器被销毁，或从容器中删除对象。
import sys
 
class A():

    def __init__(self):
        pass
 
print("创建对象 0 + 1 =", sys.getrefcount(A()))

a = A()
print("创建对象并赋值 0 + 2 =", sys.getrefcount(a))

b = a
c = a
print("赋给2个变量 2 + 2 =", sys.getrefcount(a))

b = None
print("变量重新赋值 4 - 1 =", sys.getrefcount(a))

del c
print("del对象 3 - 1 =", sys.getrefcount(a))

d = [a, a, a]
print("3次加入列表 2 + 3 =", sys.getrefcount(a))


def func(c):
    print('传入函数 1 + 2 = ', sys.getrefcount(c))
func(A())


创建对象 0 + 1 = 1
创建对象并赋值 0 + 2 = 2
赋给2个变量 2 + 2 = 4
变量重新赋值 4 - 1 = 3
del对象 3 - 1 = 2
3次加入列表 2 + 3 = 5
传入函数 1 + 2 =  3
  • 创建对象 0 + 1 = 1
  • 创建对象并赋值 0 + 2 = 2
  • 赋给2个变量 2 + 2 = 4
  • 变量重新赋值 4 - 1 = 3
  • del对象 3 - 1 = 2
  • 3次加入列表 2 + 3 = 5
  • 传入函数 1 + 2 = 3

引用计数的优缺点

优点

  • 高效、逻辑简单、只需根据规则对计数器做加减法。
  • 实用性。 一旦对象的计数器为零，就说明对象永远不可能再被用到，无须等待特定时机，直接释放内存。
    缺点
  • 需要为对象分配引用计数空间，增大了内存消耗。
  • 当需要释放的对象比较大时，如字典对象，需要对引用的所有对象循环嵌套调用，可能耗时比较长。
  • 循环引用。致命缺陷，无解

标记-清除

标记-清除算法主要用于解决循环引用问题，该算法分为两步：

  • 标记阶段。将所有的对象看成图的节点，根据对象的引用关系构造图结构。从图的根节点遍历所有的对象，所有访问到的对象被打上标记，表明对象是“可达”的。
  • 清除阶段。遍历所有对象，如果发现某个对象没有标记为“可达”，则回收。
class A():
    def __init__(self):
        self.obj = None
 
def func():
    a = A()
    b = A()
    c = A()
    d = A()

    a.obj = b
    b.obj = a
    return [c, d]

e = func()

上面代码中的引用关系如下图：


如果采用引用计数器算法，那么a和b两个对象将无法被回收。而采用标记清除法，从根节点（即e对象）开始遍历，c、d、e三个对象都会被标记为可达，而a和b无法被标记。因此a和b会被回收。
一般而言，根节点的选取包括（但不限于）如下几种：

  • 当前栈帧中的本地变量表中引用的对象，如各个线程被调用的方法堆栈中使用到的参数、 局部变量、 临时变量等。
  • 全局静态变量

分代收集

  1. 接大部分的对象生命周期短，大部分对象都是朝生夕灭。
  2. 经历越多次数的垃圾收集且活下来的对象，说明该对象越不可能是垃圾，应该越少去收集。

Python中，对象一共有3种世代：G0,G1,G2

  1. 对象刚创建时为G0。
  2. 如果在一轮GC扫描中存活下来，则移至G1，处于G1的对象被扫描次数会减少。
  3. 如果再次在扫描中活下来，则进入G2，处于G1的对象被扫描次数将会更少。

整数池

  • Python实现int的时候有个小整数池。为了避免因创建相同的值而重复申请内存空间所带来的效率问题， Python解释器会在启动时创建出小整数池，范围是[-5,256]，该范围内的小整数对象是全局解释器范围内被重复使用，永远不会被垃圾回收机制回收。
  • 在pycharm中运行python程序时，pycharm出于对性能的考虑，会扩大小整数池的范围，其他的字符串等不可变类型也都包含在内一便采用相同的方式处理了，这是一种优化机制。
x = 10
y = 10
print(x == y)

True

补充部分

赋值

链式赋值

a = 10
b = 10
c = 10
d = 10
print(f'a:{a}, b:{b}, c:{c}, d:{d}')

a:10, b:10, c:10, d:10

a = b = c = d = 10
print(f'a:{a}, b:{b}, c:{c}, d:{d}')

a:10, b:10, c:10, d:10

print(f'')
#要使用f-string输出变量的值，你可以在花括号内放置变量名，并在f-string前面加上字母"f"。这样，变量的值将会被插入到字符串中。
a = 1
b = 2
c = 3
d = 4

print(f'a: {a}, b: {b}, c: {c}, d: {d}')
#可以将变量的名称和值插入到字符串中，在输出时显示它们的值。请注意，花括号内的变量名称将被替换为对应的值。

a: 1, b: 2, c: 3, d: 4

交叉赋值

x = 100
y = 200

temp = x
x = y
y = temp
print(f'x:{x}')
print(f'y:{y}')


x:200
y:100

x, y = y, x
print(f'x:{x}')
print(f'y:{y}')

x:100
y:200

注释

# 单行注释

'''
三单引号注释
三单引号注释
'''

"""
三双引号多行注释
三双引号多行注释
"""

'\n三双引号多行注释\n三双引号多行注释\n'
  • 加双引号输出文本内容
  • 不加双引号输出变量
#\n 转义符号   放在句末代表话还没说完。
#如果要输出下图这种，要么直接'''   ''' 然后在里面敲回车
#另外一种比较麻烦，就是每一行后面都加一个转义字符\n\



___                     ___          ___          ___     
     /\  \         ___       /\  \        /\__\        /\  \    
    /::\  \       /\  \     /::\  \      /:/  /       /::\  \   
   /:/\:\  \      \:\  \   /:/\ \  \    /:/__/       /:/\:\  \  
  /::\~\:\  \     /::\__\ _\:\~\ \  \  /::\  \ ___  /:/  \:\  \ 
 /:/\:\ \:\__\ __/:/\/__//\ \:\ \ \__\/:/\:\  /\__\/:/__/ \:\__\
 \/__\:\ \/__//\/:/  /   \:\ \:\ \/__/\/__\:\/:/  /\:\  \  \/__/
      \:\__\  \::/__/     \:\ \:\__\       \::/  /  \:\  \      
       \/__/   \:\__\      \:\/:/  /       /:/  /    \:\  \     
                \/__/       \::/  /       /:/  /      \:\__\    
                             \/__/        \/__/        \/__/

标签：__,10,变量,对象,day01,引用,print
From： https://www.cnblogs.com/qingchuan/p/17554902.html

相关文章

  • 算法小菜鸟成长记录Day01-二分查找和双重指针
    二分查找和双重指针今天是代码随想录刷题的第一天，刚开始刷的时候昏昏欲睡，其中用时3h主要实现以下几个部分二分查找:其中二分查找中其收获最大部分就在于对左开右闭区间的理解，如果都是闭区间也就是【a，b】，那么在while中的条件就为while（left<=right）,确保其中是拥有元素也就是......
  • HTML-DAY01
    1.前端三剑客之一——HTML（超文本标记语言）什么是HTMLHyperTextMarkupLanguage超文本标记语言,体现可以对文本进行标记(颜色/字体大小),并且对动画,图片进行渲染等等!2.页面标准结构介绍<!DOCTYPEhtml>html5的文档类型<html>html的标准的开始标签<head>头标签<metac......
  • Java学习day01
    我在B站上大学......
  • JavaScript-Day01
    1、JavaScript：是与网页交互的脚本语言。2、组成部分：{ ECMAScript，文档对象模型（DOM），浏览器对象模型（BOM）}    2.1 ECMAScript（核心）：由ECMA-262定义并提供核心功能。<!--宿主环境-->        1.基本层面定义：语法、类型、语句、关键、保留字、操作符、全局对象。   ......
  • Day01-8 变量，常量，作用域
    变量变量就是可以变化的量java是一种强类型语言，每一个变量都必须声明其类型java变量是程序中最基本的存储单位，其要求包括变量名，变量类型和作用域typevarName  [=value][{,varName}]//不建议一行定义多个值;//数据类型      变量名=值；//可以使......
  • Day01，2023.07.04
    行程9:00到达上海信息安全测评认证中心（黄浦区陆家浜路1308号）。9:30   签订协议，领取电脑、本子等。10:20  确认负责老师，前往所在处：上海电气集团数字科技有限公司（闵行区合川路2555号2号楼）。11:00  到达，听老师与公司负责人交谈。......
  • Day01-7 类型转换
    由于java是强类型语言，所以要进行有些运算的时候，需要用到类型转换低---------------------------------------------------------------------->高byte，short，char—>int—>long—>float—>double运算中，不同类型的数据先转化为同一类型，然后进行运算//强制转换（类......
  • Day01-6 数据类型
    数据类型强类型语言要求变量的使用要符合规定，所有变量都必须先定义后才能使用java数据类型的两大类基本数据类型数值类型整数类型byte占1个字节范围：-128-127shout占2个字节范围：-32768-32767int占4个字节范围：-2147483648-2147483647long占8个字节范围：-9223372036......
  • Day01
    Markdown学习标题对应于Ctrl+1234，或者对应数量的#+""+标题名字体哈哈哈哈哈哈用对应数量的*Ctrl+u=下划线+b=粗体+i=斜体哈哈~~表示划线引用不乱于心，不困于情。不畏将来，不念过往。如此，安好。用>+""+话语 分割线用三个-或者三个*图片用英文的!此处路......
  • # Day01 Markdown学习 ##
    Day01Markdown学习标题对应于Ctrl+1234，或者对应数量的#+""+标题名字体哈哈哈哈哈哈用对应数量的*Ctrl+u=下划线+b=粗体+i=斜体哈哈~~表示划线引用不乱于心，不困于情。不畏将来，不念过往。如此，安好。用>+""+话语 分割线用三个-或者三个*图片用英文的!......

赞助商

阅读排行

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

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

Copyright © 2020-2023 IPS99 版权所有 IPS99