python-变量的基本使用

1——变量的定义

在 Python 中，每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建，变量定义之后，后续就可以直接使用了，在ipython中，如果要查看变量内容，直接输入变量名即可，不需要使用 print 函数。如果使用解释器执行，如果要输出变量的内容，必须要要使用 print 函数。在内存中创建一个变量，会包括：

1、变量的名称

2、变量保存的数据

3、变量存储数据的类型

4、变量的地址

在 Python 中定义变量时候需要指定类型，Python 可以根据 = 等号右侧的值，自动推导出变量中存储数据的类型。在Python中，数据类型可以分为数字型和非数字型。数字型又可以分为整型 (int)、浮点型（float）、布尔型（bool）（真 True 非 0 数 —— 非零即真、假 False 0）、复数型 (complex主要用于科学计算）、非数字型（字符串、列表、元组、字典）。使用 type 函数可以查看一个变量的类型。type(name)即可。数字型变量之间是可以直接进行计算的。如果变量是布尔型，在计算的时候True会转化成1，False对应的是数字0。

Python中字符串变量之间使用"+"号进行字符串的拼接，使之生成新的字符串。字符变量可以和整数配合"*"号重复生成拼接相同的字符串。数字型变量和字符串之间不能进行其他计算。

在Python中如果想获取用户键盘上输入的信息，使用input函数即可。而读取的信息则是以字符串类型返回的。如：

字符串变量 = input("提示信息：")

下面我们来说说不同变量类型之间怎么进行转换。首先是int（x），将 x 转换为一个整数，float（x）：将 x 转换到一个浮点数。在 Python 中使用 print 函数将信息输出到控制台的时候，如果希望同时输出文字和数据的时候。就需要使用格式化字符操作。%被称为格式化操作符，类似于C语言，专门用于处理字符串中的格式。包含 % 的字符串，被称为格式化字符串。%和不同的字符连用，不同类型的数据需要使用不同的格式化字符。下面单独讲讲不同的结合方式及其含义。

%s 字符串
%d 有符号十进制整数，%06d 表示输出的整数显示位数，不足的地方使用 0 补全
%f 浮点数，%.2f 表示小数点后只显示两位
%% 输出 %
语法格式如下：
print("格式化字符串" % 变量1)
print("格式化字符串" % (变量1, 变量2...))

文中介绍的字符串一个非常重要的知识点：字符串格式化输出。

格式化怎么理解？简答来说：就是让字符串按照我们设定的格式来输出，达到我们想要的结果。主要是有4种方式：

%：基于占位符的格式化
format()函数的格式化：重点掌握
f-string格式化：重点掌握
字符串模板函数string template

一、占位符%

常见格式符

格式化符号其实是为真实的值预留出一个空位，而且还可以控制显示的格式。格式符包含一个类型码，用来显示不同的数据类型，比如字符串、二进制、指数等。常见的不同的占位符如下：

%s：字符串 (采用str()的显示)，常用
%r：字符串 (采用repr()的显示)
%c：单个字符，格式化字符及其ASCII码
%b：二进制整数
%u：格式化无符号整数，常用
%d：格式化十进制整数，常用
%i：十进制整数
%o：八进制整数
%x：十六进制整数
%g：指数(e)或浮点数%f (根据显示长度)
%G：指数(E)或浮点数%F (根据显示长度)
%e：指数 (基底写为e)，用科学计数法格式化浮点数
%E：指数 (基底写为E)，用法同%e
%f：浮点数，格式化浮点数字，可以指定小数点后面的精度，常用
%F：浮点数，与%f相同
%%：字符“%”，用来显示百分号%

对齐问题

关于对齐问题：

1. ^：居中对齐
2. >：右对齐
3. <：左对齐
4. +、-：显示正负号

语法形式

常用的语法形式为：%[(name)][flags][width].[precision] typecode

(name)：参数的名称，可以省略；如果使用必须加上()
flags：对齐标志位；可以是+、-、“”、0；+右对齐，-左对齐，""填充一个空格；0表示左侧使用0填充
width：显示的宽度
precision：小数点后的精度

多种类型连用

print("%9.3f" % 2.3)

    2.300  #  前面4个空格

第一个 % 后面的内容为显示的格式说明，9 为显示宽度，3 为小数点位数，f 表示输出为浮点数类型
第二个 % 后面为显示的内容来源，输出结果默认为右对齐，2.300 长度为 5，故前面有4个空格

print("%+9.3f" % 2.3)  # 带上+符号输出，9表示宽度，3表示小数位

   +2.300

print("%-9.3f" % 2.3)  # -表示左对齐输出

2.300

print("%-9.3f" % -2.3)

-2.300

# 我们显示声明3个变量

name = "Yule Cottage"  # 字符串类型
age = 25  # 整数类型
height = 1.76   # 浮点数类型

# 1、浮点数默认是6位小数
# 2、%f和%F相同

print("我是：%s，年龄: %d，身高是：%f" % (name,age,height))

我是：Yule Cottage，年龄: 25，身高是：1.760000

# 指定浮点数的小数位

print("我是：%s，年龄: %d，身高是：%.3f" % (name,age,height))

我是：Yule Cottage，年龄: 25，身高是：1.760

下面的代码是通过字典对的形式来传入不同的数据类型，字典（后面会介绍python的字典）的值就是待格式的内容。

需要注意的是name、age、height必须写在%号的后面

print("我是：%(name)s，年龄: %(age)d，身高是：%(height).3f" % {"name":name,"age":age,"height":height})

我是：Yule Cottage，年龄: 25，身高是：1.760

输出不同进制

print("八进制：%o，十进制：%i，十六进制：%x" %(age,age,age))

八进制：31，十进制：25，十六进制：19

# print("二进制：%b" %(age))   # 二进制不能使用

bin(age)  # 通过bin函数查看

'0b11001'

输出的宽度、精度等设置

number = 1.23456789

# 宽度为10，保留小数点后4位，默认是右对齐
print("%10.4f" % number)

    1.2346

print("%-10.4f" % number)  # -符号表示左对齐，显示4位小数

1.2346

# 右对齐，保留10位小数，不足的用0补齐

print("%10.10f" % number)

1.2345678900

print("%-10.8f" % number)  # 左对齐，保留8位小数

1.23456789

# 左对齐，保留7位小数，会自动地进行四舍五入

print("%-10.7f" % number)

1.2345679

下面是针对字符串的宽度等输出设置：

name

'Yule Cottage'

print("%.10s" % name) # 9个字母+一个空格：左对齐

Yule Cotta

print("%.15s" % name) # 如果位数不够，直接全部输出

Yule Cottage

print("%10.6s" % name) # 右对齐，取出6个字符

    Yule C

解释：总长度为10，前面4个空格，加上4+一个空格+C

二、format格式化

从python2.6+开始，新增了一种格式化字符串的函数str.format，可以说极大地增强了字符串格式化的功能，基本语法是通过{}和:来代替占位符%

接收多个不限制的参数
位置可以不按照顺序

语法形式

{<参数序号>:<格式控制标记>} ，中间有一个冒号，不能省略！！！

name = "Yule Cottage"  # 字符串类型
age = 25  # 整数类型
height = 1.76   # 浮点数类型
sex = "男"

多个参数连用

# 1、不设置位置
print("名字是：{}，年龄是：{}，身高是：{}，性别：{}".format(name,age,height,sex))

名字是：Yule Cottage，年龄是：25，身高是：1.76，性别：男

# 2、设置位置参数

print("名字是：{0}，年龄是：{1}，身高是：{2}，性别：{3}".format(name,age,height,sex))

名字是：Yule Cottage，年龄是：25，身高是：1.76，性别：男

# 设置位置参数
# 索引从0开始；2号位对应的height

print("名字是：{0}，身高是：{2}，年龄是：{1}，性别：{3}".format(name,age,height,sex))

名字是：Yule Cottage，身高是：1.76，年龄是：25，性别：男

print("性别：{3}，身高是：{2}，名字是：{0}，年龄是：{1}".format(name,age,height,sex))

性别：男，身高是：1.76，名字是：Yule Cottage，年龄是：25

# 3、元组形式
# 使用*进行解析

information = ("Peter",25)

print("姓名是：{}，年龄是：{}".format(*information))

姓名是：Peter，年龄是：25

# 4、字典形式
# 参数为字典时候，通过**进行解析配对

print("名字是：{name}，年龄是：{age}，身高是：{height}，性别：{sex}".format(**{"name":name,"age":age,"height":height,"sex":sex}))

名字是：Yule Cottage，年龄是：25，身高是：1.76，性别：男

# 5、直接变量赋值

print("名字是：{name}，年龄是：{age}，身高是：{height}，性别：{sex}".format(name="Yule Cottage",age="2岁",height="1.75m",sex="男"))

名字是：Yule Cottage，年龄是：2岁，身高是：1.75m，性别：男

对齐

宽度为20，我们实现居中、靠左、靠右对齐

name

'Yule Cottage'

print("{:^20s}".format(name))  # 居中
print("{:>20s}".format(name))  # 靠右
print("{:<20s}".format(name))  # 靠左

    Yule Cottage    
        Yule Cottage
Yule Cottage

数值多种形式

首先我们还是看看对齐问题，浮点数的对齐只保留6位小数：

pi = 3.1415926

print("{:^20f}".format(pi))  # 居中  # 默认只保留6位小数
print("{:>20f}".format(pi))  # 靠右
print("{:<20f}".format(pi))  # 靠左

      3.141593      
            3.141593
3.141593

看看不同情况下的输出格式，浮点数需要带上小数点，默认全部是左对齐：

# 不同的输出方式

print("{}".format(pi))  # 原数据
print("{:.2f}".format(pi))   # 2位小数
print("{:>.10f}".format(pi))  # 位数不足，右侧补0
print("{:.4%}".format(pi))  # 百分比输出
print("{:.2e}".format(pi))

3.1415926
3.14
3.1415926000
314.1593%
3.14e+00

填充

sex

'男'

print("{0:30}".format(sex))  # 字符串默认左对齐
print("{:>30}".format(sex))  # 改成右对齐
print("{0:30}".format(age))  # 数值类型默认右对齐
print("{:<30}".format(height)) # 改成左对齐

# 指定填充的字符

print("{:*>30}".format(sex))  # *
print("{:+>30}".format(sex))  # +
print("{:+^30}".format(sex))  # 居中后填充+
print("{:+<30}".format(height)) # +

*****************************男
+++++++++++++++++++++++++++++男
++++++++++++++男+++++++++++++++
1.76++++++++++++++++++++++++++

千位分隔符

主要是用来显示数字的千位分隔符，在货币金额中使用的比较多：

b = 1003005000600

print("{:-^20}".format(b))   # 不用逗号
print("{:-^20,}".format(b))  # 用逗号

---1003005000600----
-1,003,005,000,600--

# 小数的千位分隔符显示

print("{0:-20,}".format(12567.98760))  # 不填充
print("{0:-^20,}".format(12567.98760))  # 居中+填充
print("{0:->20,}".format(12567.98760))  # 右对齐+填充
print("{0:-<20,}".format(12567.98760))  # 左对齐+填充

         12,567.9876
----12,567.9876-----
---------12,567.9876
12,567.9876---------

精度

精度输出的时候前面必须有一个小数点开头，具有两层含义：

浮点数：表示输出小数位的有效位数
字符串：精度表示输出的最大长度

pi

3.1415926

"{:.3f}".format(pi)

'3.142'

"{:30.5f}".format(pi)  # 小数点后5位，整体宽度30

'                       3.14159'

"{:*^30.5f}".format(pi)  # 小数点后5位，宽度30,居中后补充*

'***********3.14159************'

name

'Yule Cottage'

"{:.4}".format(name)  # 最大长度为4

'Yule'

"{:.6}".format(name)  # 输出最大长度为6

'Yule C'

多种输出类型

表示输出整数和浮点数类型的格式规则。对于整数类型，输出格式包括6 种：

c: 输出整数对应的 Unicode 字符；
b: 输出整数的二进制方式；
o: 输出整数的八进制方式；
d: 输出整数的十进制方式；
x: 输出整数的小写十六进制方式；
X: 输出整数的大写十六进制方式；

下面的例子表示的是365的二进制、Unicode字符、十进制、小写16进制和大写的16进制的不同输出格式：

"{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(365)

'101101101,ŭ,365,555,16d,16D'

如果是浮点数类型，那么输出格式包括4种：

e: 输出浮点数对应的小写字母 e 的指数形式；
E: 输出浮点数对应的大写字母 E 的指数形式；
f: 输出浮点数的标准浮点形式；
%: 输出浮点数的百分形式。

浮点数输出时尽量使用<.精度>表示小数部分的宽度，有助于更好控制输出格式。

"{0:e},{0:E}".format(3.1415)

'3.141500e+00,3.141500E+00'

"{0:f},{0:F}".format(3.1415)

'3.141500,3.141500'

"{0:%}".format(3.1415)  # 保留6位小数，百分比输出

'314.150000%'

"{0:.2%}".format(3.1415)  # 2位小数，百分比输出

'314.15%'

三、f-string

f-string是python3.6开始引入的新字符串格式化方法。其实它的方法很多和format是类似的，下面通过具体的例子来讲解。

简单例子

首先我们看一个简单的例子，说明f-string如何使用：

a = "hello"
b = "python"

f"{a} {b}"

'hello python'

指定变量格式化

# 我们显示声明3个变量

name = "Yule Cottage"  # 字符串类型
age = 25  # 整数类型
height = 1.76   # 浮点数类型

f'名字是：{name}，年龄是：{age}，身高是：{height}'  # 前面加上f

'名字是：Yule Cottage，年龄是：25，身高是：1.76'

我们和format进行一下对比：

"名字是：{}，年龄是：{}，身高是：{}".format(name,age,height)  # format函数在最后面

'名字是：Yule Cottage，年龄是：25，身高是：1.76'

指定表达式格式化

如果后面的string部分是表达式，也可以进行格式化

f'{1+2+3}'

'6'

f'{1*2*3*4}'

'24'

对表达式进行变量的赋值再格式化：

x = 100
y = 50

f"{x*y + x/y}"  # 100*50 + 100 / 50 结果是浮点数

'5002.0'

指定函数格式化

上面的例子是直接赋值再通过表达式来格式化，我们其实可以将上面的表达式改成函数，传入参数来格式化，函数可以是：

python自带的函数
自定义的函数

# 自带函数
print(f'my name is: {name}')  # 原数据
print(f'my name is: {name.upper()}')  # 全部变成大写字母

my name is: Yule Cottage
my name is: YULE COTTAGE

# 自己写个函数

def test(a,b):
    return a * b + a / b

f'{test(100,50)}'

'5002.0'

# 或者直接写成lambda 匿名函数

f'执行的结果是：{(lambda x,y: x*y + x/y)(100,50)}'

'执行的结果是：5002.0'

对齐

<：靠左，字符串默认方式
>：靠右，数值类型默认方式
^：居中

print(f'{name}')  # 字符串默认左
print(f'{name:>20.10s}')  # > 右对齐 长度20  字符串最大长度10
print(f'{name:<20.12s}')  # < 左对齐 长度20  字符串最大长度12

Yule Cottage
          Yule Cotta
Yule Cottage

pi = 3.1415926

print(f'{pi}')  # 原数据
print(f'{pi:^10.4f}')  # 居中 长度为10  保留4位小数
print(f'{pi:>10.4f}')  # 靠右 长度为10  保留4位小数
print(f'{pi:<10.4f}')  # 靠左 长度为10  保留3位小数

填充

print(f'{pi}')  # 原数据

print(f'{pi:*^10.4f}')  # 填充*：居中 长度为10  保留4位小数
print(f'{pi:*>10.4f}')  # 填充*：靠右 长度为10  保留4位小数
print(f'{pi:*<10.4f}')  # 填充*：靠左 长度为10  保留3位小数

3.1415926
**3.1416**
****3.1416
3.1416****

千位分隔符

和format中的千位分隔符相同，主要是用于金融货币中，自带金钱属性呀。可以使用逗号或者其他符号，常用逗号：

money = 1234567890

print(f'{money:,f}')  # 输出保留6位小数

1,234,567,890.000000

print(f'{money:_f}')   # 使用下滑线

1_234_567_890.000000

四、字符串模板string template

string.Template是将一个string设置为模板，通过替换变量的方法，最终得到想要的string

from string import Template  # 导入模板

template_string = '$name is $sex'

s = Template('$name is $sex')
s.substitute(name="Peter",sex="male")

'Peter is male'

from string import Template  # 导入模板

template_string = '$name is $sex'  # 1、设置模板
s = Template(template_string)  

dic = {"name":"Peter","sex":"male"}

s.substitute(dic)

'Peter is male'

在上面的例子中：

模板s中有以$符号说明模板中有两个变量名，用实际的变量来替换。
格式是dictionary，并且字典中的key值与模板中的变量名要保持一致
string.Template默认用$符号来标识出变量；可以进行修改

from string import Template
class MyTemplate(Template):     
    delimiter = '%'
...     
s = MyTemplate('%who knows?')  # 改变符号
s.substitute(who='Peter')
'Peter knows?'

五、格式整理

整理下关于对齐、精度、数值类型的符号等知识点：

对齐

<：右对齐（数值默认对齐方式）
>：左对齐（字符串默认对齐方式）
^：居中

符号

+：负数前加负号（-），正数前加正号（+）
-：负数前加负号（-），正数前不加任何符号（默认）
空格：负数前加负号（-），正数前加一个空格

宽度和精度

width：指定宽度为width
width.precision：宽度为width，精度为precision
0width：宽度为width，指定高位用0补足宽度

六、总结

1、%占位符

表达式比较直观，容易上手；但是当参数变多的时候，格式就变得繁琐，这种方式现在几乎淘汰

2、format函数

方法比较灵活，能够自己设置参数来对应相应的变量；参数变多的时候，表达式同样繁琐，整个式子会非常长

3、f-string

相对前两种方式会灵活些，也更直观。Python3.6开始出现，语句格式可能稍显复杂

重点还是要掌握format函数和f-string

--END--

ython

Python是动态类型语言。
变量不需要显示声明类型。根据变量引用的对象，Python解释器自动确定数据类型。

Python基本格式

使用\行连接符 ----> 一行比较长的程序分为多行，Python解释器仍然解释位同一行。

注释

对象

内存示意图

引用

变量称之为对象的引用。变量存储的就是对象的地址。变量通过地址引用了"对象"。
变量位于：栈内存
对象位于：堆内存

标识符规则

Python标识符命名规则

开发中，我们通常约定俗成遵守如下规则：

类型	规则	例子
模块和包名	全小写字母，尽量简单。若多个单词之间用下划线	math, os, sys
函数名	全小写字母，多个单词之间用下划线隔开	phone, my_name
类名	首字母大写，采用驼峰原则。多个单词时，每个单词第一个字母大写，其余部分小写	MyPhone、MyClass、Phone
常量名	全大写字母，多个单词使用下划线隔开	SPEED、MAX_SPEED

变量

变量名 = 变量值；
变量：'容器'；
变量的规则：标识符由字母、下划线和数字组成，且数字不能开头；严格区分大小写；不能使用关键字；
变量名，函数名和文件名全小写，使用下划线连接；类名遵守大驼峰命名法；常量名全大写。

变量的声明和赋值：用于一个变量绑定一个对象上，格式：变量 = 表达式；
变量在使用前必须先被初始化（先被赋值）

删除变量和垃圾回收机制

a=123
del a
print(a)

链式赋值

链式赋值用于同一个对象赋值给多个变量。

x = y = 123

系列解包赋值

系列数据赋值给对应相同个数的变量（个数必须保持一致）

a,b,c=4,5,6 相当于：a=4;b=5;c=6

# 使用系列解包赋值实现变量值互换
a,b=1,2
a,b=b,a # 变量值互换
print(a,b) # 2,1

基本内置数据类型

变量类型

int ---- 整数（可以任意大）

>>> 12
12
>>> 0b101
5
>>> 0o19
SyntaxError: invalid syntax
>>> 0o10
8
>>> 0xff
255
>>> 0xf
15
>>> 0x10
16

int()实现类型转换

>>> int("456")
456
>>> int("456abc")
Traceback (most recent call last):
 File "", line 1, in <module>
  int("456abc")
ValueError: invalid literal for int() with base 10: '456abc'
>>> int("456.78")
Traceback (most recent call last):
 File "", line 1, in <module>
  int("456.78")
ValueError: invalid literal for int() with base 10: '456.78'
>>>

自动转型

整数和浮点数混合运算时，表达式结果自动转型成浮点数。比如：2+8.0的结果是10.0

float ---- 浮点数

类型转换和四舍五入

增强型赋值运算符

运算符+、-、*，/、//、**和%和赋值符=结合可以构成“增强型赋值运算符”。

运算符	例子	等价
+=	a += 2	a = a + 2
-=	a -= 2	a = a-2
*=	a *= 2	a = a * 2
/=	a /= 2	a = a / 2
//=	a //= 2	a = a//2
**=	a **= 2	a = a**2
%=	a %= 2	a = a % 2

复合赋值可以让程序更加精炼，提高效率。

运算符	描述	示例	等价于
+=	加法赋值字符串拼接	sum += na += “sss”	sum = sum + na = a + “sss”
-=	减法赋值	num -= n	num = num - n
*=	乘法赋值	a *= b	a = a * b
/=	浮点除赋值	a/=b	a = a / b
//=	整数除赋值	a//=b	a = a//b
%=	取余赋值	a%=b	a = a % b
**=	幂运算赋值	a**=2	a = a**2
<<=	左移赋值	a<<=2	a = a<<2
>>=	右移赋值	a>>=2	a = a>>2
&=	按位与赋值	a&=b	a = a&b
\|=	按位或赋值	a\|=b	a=a\|b
^=	按位异或赋值	a^=b	a = a^b

⚠️与C和JAVA不一样，Python不支持自增(++)和自减(--)

time

import time
b = int(time.time())
totalMinutes = b//60
totalHours = totalMinutes//60
totalDays = totalHours//24
totalYears = totalDays//365 #忽略闰年情况

bool ---- 布尔值

True和False定义成了关键字，其实本质还是1和0，可以可数字相加。

在Python语言底层，会将布尔值True看作1，将布尔值False看作0，尽管从表面上看，True和1、False和0是完全不同的两个值，但实际上，它们是相同的。

在Python语言中有一些特殊的布尔类型值为False，例如False、0、0.0、空值None、空序列对象（空列表、空元祖、空集合、空字典、空字符串）、空range对象、空迭代对象。其他情况，均为True。

a = True
b = 3
c = a+b     #c的值是：4
print(c)
print('空字符串的布尔类型的值:',bool(""))      #False
print('空列表布尔类型的值:',bool([]))        #False
print('None布尔类型的值:',bool(None))     #False
print('0布尔类型的值:',bool(0))           #False
print('字符串True和False转成布尔都是True：',bool("False")) #True

String

单引号和双引号为了交叉使用；
'''''' 三引号保留格式的输入；
+ 字符串之间的拼接

print() ---- 输出

input() ---- 输入

阻塞型函数；
都会被封装成str.

类型转换

str ----> int

int('1234')

如果数字是字符串类型，转int会报错。
a = '9.9'
int(a)

str ----> float

float('12.34')

int ----> str

str(1234)

bool ----> int

flag = False
int(flag) # 0
float(flag) # 0.0
str(flag) # 'False'

int ----> bool

a = 2
bool(a) # True
a = 1
bool(a) # True

a = 0
bool(a) # False

a = ''
bool(a) # False

算术运算符

Python支持整数(如：50,520)和浮点数(如：3.14,10.0, 1.23e2)，我们可以对数字做如下运算。

运算符	说明	示例	结果
+	加法	3+2	5
-	减法	30-5	25
*	乘法	3*6	18
/	浮点数除法	8/2	4.0
//	整数除法	7//2	3
%	模（取余）	7%4	3
**	幂	2**3	8

# 使用divmod()函数同时得到商和余数
divmod(13,3) # (4,1) 返回一个元组

c = 3
c / 2 # 除法
c // 2 # 整除
2 ** 3 # 2的3次方
3 % 2  # 取模 取余

number = int(input("请输入一个3位整数："))
print('个位数：', number % 10)
print('十位数：', number // 10 % 10)
print('百位数：', number // 100)

加法操作

乘法操作

位运算符

按位运算符是把数字看作二进制来进行计算的。Python中的按位运算法则如表所示。

运算符	描述
&	按位与运算符:参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则0
\|	按位或运算符:只要对应的二个二进位有一个为1时,结果为就为1.
^	按位异或运算符:当两对应的二进制位相异时,结果为1
~	按位取反运算符:对数据的每个二进制取反,既把1变为0,把0变为1,~x类似于-x-1
<<	左移动运算符:运算数的每个二进位全部左移若干位,由”<<”右边的数据指定移动的位数,高位丢弃,低位补0
>>	右移动运算符:把”>>”左边运算数的每个二进制位全部右移若干位,”>>”右边的数指定移动的位数

a = 0b11001
b = 0b01000


print(bin(a|b))  #bin()可以将数字转成二进制表示  '0b11001'
print(bin(a&b))  #与
print(bin(a^b))  #异或


print(3<<2)  #左移1位相当于乘以2.左移两位相当于：3*4
print(20>>1)  #右移移位相当于除以2

比较运算符

所有比较运算符返回1表示真，返回0表示假。这分别与特殊变量True和False等价。

以下假设变量a为15，变量b为30：

运算符	描述	实例
==	等于 - 比较对象的值是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象的值是否不相等	(a != b) 返回 true.
>	大于 - 返回x是否大于y	(a > b) 返回 False。
<	小于 - 返回x是否小于y。	(a < b) 返回 true。
>=	大于等于 - 返回x是否大于等于y。	(a >= b) 返回 False。
<=	小于等于 - 返回x是否小于等于y。	(a <= b) 返回 true。

a = 4
print(a<=30)
#关系运算符可以连用
if(3<a<10):
  print("a在3和10之间")

赋值运算符

逻辑运算符

运算符	格式	说明
or 逻辑或	x or y	x为true，则不计算y，直接返回true；x为false，则返回y
and 逻辑与	x and y	x为true，则返回y的值x为false，则不计算y，直接返回false
not 逻辑非	not x	x为true，返回false；x为false，返回true

#测试逻辑运算符
a,b,c=10,20,30
print((a<b) and (b<c))  #and并且  输出结果是True
print((a>b) or (b>c))  #or或者  输出结果是False
print(not(b<c))     #not非   输出结果是False

同一运算符

同一运算符用于比较两个对象的存储单元，实际比较的是对象的地址。

运算符	描述
is	is是判断两个标识符是不是引用同一个对象
is not	is not 是判断两个标识符是不是引用不同对象

is 与 == 区别：

is 用于判断两个变量引用对象是否为同一个，既比较对象的地址。

== 用于判断引用变量引用对象的值是否相等，默认调用对象的 __eq__()方法。

a=20
b=20
c=30
print("a和b是同一个对象",a is b)  #执行结果:True
print("a和c是同一个对象",a is c)  #执行结果False
print("a和c不是同一个对象",a is not c)  #执行结果True

成员运算符

成员运算符测试实例中包含了一系列的成员，包括字符串，列表或元组。

运算符	描述
in	如果在指定的序列中找到值返回 True，否则返回 False
not in	不在，则返回True

a = "python"
b = "py"
print(b in a)    #True
c = [10,20,30]
print(10 not in c)  #False

整数缓存问题

运算符优先级

复杂的表达式一定要使用小括号；
乘除优先加减；
位运算和算术运算>比较运算符>赋值运算符>逻辑运算符

运算符	说明
and , or , not	布尔与、布尔或、布尔非
is , is not	同一性判断，判断是否为同一个对象
in , not in	判断是否在指定序列中
<,<=,>,>=,!=,==	比较值是否相当，可以连用
\| ^ &	按位或，按位异或、按位与
<<, >>	移位
~	按位翻转
+,-,*,/,//,%	加，减，乘，浮点除、整数除、取余
**	幂运算

进制

在线咨询

上一篇：HTML常用基础标签：图片与超链接标签全解！
下一篇：简单小程序：登录页面（html）

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

整合营销服务商

python-变量的基本使用

一、占位符%

常见格式符

对齐问题

语法形式

多种类型连用

输出不同进制

输出的宽度、精度等设置

二、format格式化

语法形式

多个参数连用

对齐

数值多种形式

填充

千位分隔符

精度

多种输出类型

三、f-string

简单例子

指定变量格式化

指定表达式格式化

指定函数格式化

对齐

填充

千位分隔符

四、字符串模板string template

五、格式整理

对齐

符号

宽度和精度

六、总结

ython

Python基本格式

注释

对象

内存示意图

引用

标识符规则

Python标识符命名规则

变量

删除变量和垃圾回收机制

链式赋值

系列解包赋值

基本内置数据类型

变量类型

int ---- 整数（可以任意大）

float ---- 浮点数

time

bool ---- 布尔值

String

print() ---- 输出

input() ---- 输入

类型转换

算术运算符

位运算符

比较运算符

赋值运算符

逻辑运算符

同一运算符

成员运算符

整数缓存问题

运算符优先级

进制

您的项目需求