python笔记2-变量的创建

变量与简单数据类型

变量

变量的创建

• 变量的概念

  • 代码：处理数据
  • 变量：存储数据

• 创建变量

  • 变量名 = 变量值
  • 变量定义后，后续可以直接使用
  • 变量必须先定义后使用
  • =等号两边留一个空格
  • 

• 多个变量赋值

  • 

  price = 10.5
  weight = 7.5
  money = price * weight
  print("总共消费了 %.2f 元" % money)
  

  

变量的修改

创建变量后，可以在代码中重新赋值。

year = 2023
print(year)
year = 2024
print(year)

money = "十元"
print(money)
money = 10
print(money)

python对数据类型不像java严格

price = 10.5
weight = 7.5
money = price * weight
print("总共消费了 %.2f 元" % money)
money = money - 5
print("优惠后，总共消费了 %.2f 元" % money)

常量：程序在运行过程中，值永远不变的量。

python没有专门的常量类型，一半约定使用大写表示常亮。

变量的命名

标识符：程序员定义的变量名，函数名。

名字需要见名知意。

这个是长江 市长 江大桥还是长江市 长江大桥？

a = '长江市长江大桥'
bridge = '长江市长江大桥'

标识符：

• 可以由字母、下划线、数字组成
• 不能以数字开头
• 能用中文，但不推荐
• 不能与关键字重名

关键字：

• 关键字就是在python内部已经使用的标识符
• 关键字具有特殊的功能和含义
• 开发者不允许定义和关键字相同的名字的标识符

关键字，使用以下函数可以打印出来

import keyword

print(keyword.kwlist)

[
    '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'
]

变量命名规则：

• 一种惯例，不是绝对与强制
• 增加代码的识别和可读性

python中，变量名有两个或多个单词组成时，可以按照一下方式命名：

• 下划线命名法

  • 每个单词都用小写

  • 单词与单词之间使用下划线连接：first_name,last_name

• 驼峰命名法

  • 小驼峰
    • 第一个单词首字母小写开始，后面单词首字母大写firstName,lastName
  • 大驼峰
    • 每一个单词的首字母都大写FirstName,LastName

变量的数据类型

python中定义变量不需要指定类型（在其他很多高级语言中都需要）

可以使用type和isinstance来测试和判断数据类型

a = '1234absd'
print(type(a))
print(isinstance(a, str))

a = 1234
print(type(a))
print(isinstance(a, str))

简单数据类型

整型（Integers）

python可以处理任意大小的整数，包括负整数，在程序中的表示方法和数学上的写法一模一样。

# 整数的变量
num = 10
print(num)

# 负数
num2 = -10
print(num2)

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

# 输入一个数字计算
num3 = input("请输入一个数字：")
print(type(num3))
num3 = int(num3) + 10
print(num3)

浮点数（Floating point numbers）

由整数部分和小数部分组成。

注意：运算可能有四舍五入的误差。

# 浮点数的计算
import math

n1 = 0.1234
print("n1的数据类型", type(n1))
n2 = 0.2
print(n1 + n2)
n3 = 0.1
print(n2 + n3)
# 四舍五入round
n4 = round(n3 + n2, 2)
print(n4)
n5 = 0.256
print(n3 + n5)
n6 = round(n3 + n5, 2)
print(n6)
# 取整
n7 = 12.1
n8 = 145.232352
n9 = n7 + n8
# 向上取整
print("结果是：", n9)
ceil = math.ceil(n9)
print("向上取整的结果是", ceil)
floor = math.floor(n9)
print("向下取整的结果是", floor)

布尔型（Boolean）

Boolean类型的变量只有True,False两种值，首字母大写。

作为真假的判断。

在python中，能够解释为假的值有

• None
• 0
• 0.0
• False
• 所有的空容器
  • 空列表
  • 空元组
  • 空字典
  • 空集合
  • 空字符串

a = True
b = False
c = 0
d = None
e = 0.0
print("a的数据类型：", type(a))
print("b的数据类型：", type(b))
print("c的数据类型：", type(c))
print("c是不是int数据类型：", isinstance(c, int))
print("d的数据类型：", type(d))
print("e的数据类型：", type(e))

字符串（String）

字符串概念

• 字符串就是一串字符，是编程语言中表示文本的数据类型。
• 在python中可以使用一对单引号也可以使用一对双引号定义一个字符串
• 字符串以单引号或者双引号括起来的任意文本，也可以是以三单引号或者三双引号的任意文本。

s1 = 'hello'
print(s1)
s2 = "hello"
print(s2)
s3 = '''2024
hello 
word
'''
# 如果三个单引号在单独一行，该字符串首尾皆有一空行
print(s3)
s4 = "It's a hat"
print(s4)
# 转义字符\
s5 = '1234\'hhh\"6666'
print(s5)

字符串运算

• 字符串加法

  • 字符串拼接

  • print('====字符串拼接=====')
    # 字符串拼接
    print(s1 + s3)# hello2024
    print(s1 + s4)
    print('====字符串与数字拼接=====')
    n = 5
    # print(s1 + n)  #字符串与数字不能相加，要类型转换
    print(s1 + str(n))
    

• 字符串乘法

  • 字符串重复

  • print('====字符串乘法=====')
    print(s1 * 2)# hellohello
    print('s1' * 2)# s1s1
    print(2 * s1)# s1s1
    

字符串索引

索引：可以使用索引获取一个字符串中指定位置的字符，索引计数从0开始。

s = "hello,word"
print("第一位", s[0]) # 第一位 h
print(s[4])# o
print(s[-1])# d

# 切片 变量名[起始索引:结束索引+1:步数]，包头不包尾
# 步数不写，默认为1
# 起始索引，默认为0，也可以不写
# 结束索引，默认为-1，也可以不写
s = "hello,word"
print("=====切片====", )
print(s[0:4])  # hell            
print(s[1:4])  # ell
print(s[6:9])  # wor
print(s[0:9])  # hello,wor
print(s[0:9:1])  # hello,wor
# 第三个参数表示隔几个取
print(s[0:9:2])  # hlowr
s2 = '123456789'
print(s2)  # 123456789
print(s2[0:9:2])  # 13579
print(s2[:9:2])  # 13579
print(s2[1:9:2])  # 2468
print(s2[::2])  # 13579

# 字符串反转
s2 = '123456789'
print("=====字符串反转====", )
print(s2)  # 123456789
print(s2[-1:-10:-1])  # 987654321
print(s2[::-1])  # 987654321
print(s2[-1:-len(s2):-1])  # 98765432

数据类型转换

转换为整数int

print("===转换为整数int===")
# 字符串str-->整数int
# 纯数字才能转
s = '2024'
n = int(s)
print(type(s), type(n))  # <class 'str'> <class 'int'>
# 浮点数float--->整数int
s1 = 2.23
print(int(s1))  # 2
# bool--->整数int
s2, s3 = True, False
print(int(s2), int(s3))  # 1 0

转换为浮点数float

print("===转换为浮点数float===")
# str -->float
print(float(s))  # 2024.0
s4 = 23.33
print(float(s4))  # 23.33
# int -->float
n = 2024
print(float(n))  # 2024.0
# bool --> float
print(float(s2), float(s3))  # 1.0 0.0

转换为布尔bool

print("===转换为布尔bool===")
# str-->bool
s = 'sdw33'
print(bool(s))  # True
s1 = ""
print(bool(s1))  # False
# int -->bool
n = 1
print(bool(n))  # True
n = 0
print(bool(n))  # False
# float-->bool
f = 3.0
print(bool(f))  # True
f = 0.0
print(bool(f))  # False

转换为字符串str

print("===转换为字符串str===")
# int -->str
n = 5
print(str(n))  # 5
print(type(str(n)))  # <class 'str'>
# floar -->str
f = 5.3
print(str(f))  # 5.3
print(type(str(f)))  # <class 'str'>
# bool -->str
a = True
print(str(a))  # True
print(type(str(a)))  # <class 'str'>

进制的转换

print("===进制转换===")
s = '101'
print(int(s, 2))  # 5
s = '10a'
print(int(s, 16))  # 266
s = '10'
print(int(s, 8))  # 8
s = '10'
print(int(s, 10))  # 10

小整数地址问题

• python中的小整数，指的是**-5~256**之间的整数
• 当在python中创建一个整数对象时，python会根据该整数的值动态的为其分配内存空间。
  对于小整数，python会使用“小整数缓存”的机制来优化内存使用。这个缓存池中的整数对象会被重复利用，而不是为每个新创建的小整数分配新的内存空间。这样可以减少内存分配和释放的开销，提高程序性能。
• 如果需要跟踪python对象的内存地址，可以使用内置函数id()来获取对象的唯一标识符，这个标识符通常可以用来近似的表示对象的内存地址。
  但是请注意：这个标识符并不是真正的内存地址，而是有python解释器生成的一个唯一标识符，用于区分不同的对象实例。

a = 3
b = 3
c = 200
d = -4
e = -4
f = -6
print(id(a))# 140720363534840
print(id(b))# 140720363534840
print(id(c))# 140720363541144
print(id(d))# 140720363534616
print(id(e))# 140720363534616
print(id(f))# 1932368806288

建的小整数分配新的内存空间**。这样可以减少内存分配和释放的开销，提高程序性能。

• 如果需要跟踪python对象的内存地址，可以使用内置函数id()来获取对象的唯一标识符，这个标识符通常可以用来近似的表示对象的内存地址。
  但是请注意：这个标识符并不是真正的内存地址，而是有python解释器生成的一个唯一标识符，用于区分不同的对象实例。

[外链图片转存中…(img-qduEW1t4-1723372453022)]

a = 3
b = 3
c = 200
d = -4
e = -4
f = -6
print(id(a))# 140720363534840
print(id(b))# 140720363534840
print(id(c))# 140720363541144
print(id(d))# 140720363534616
print(id(e))# 140720363534616
print(id(f))# 1932368806288