Python中的变量、运算符与流程控制

目录
  • 一、执行Python程序的两种方式
    • 1、交互式
    • 2、命令行式
  • 二、变量
    • 1、变量的组成
    • 2、变量名的定义规范
    • 3、定义变量的两种方式
    • 4、常量
  • 三、Python变量内存管理
    • 1、引用计数
    • 2、垃圾回收机制
    • 3、小整数池
    • 4、内存地址与数据类型
    • 5、实例:
  • 四、花式赋值
    • 1、 链式赋值
    • 2、 交叉赋值
    • 3、多个变量赋值
  • 五、与用户交互
  • 六、格式化输出
    • 1、 占位符(旧式字符串格式化,逐步淘汰)
    • 2、 format格式化
      • 1、格式:<模板字符串>.format(<逗号分隔的参数>)
      • 2、模板字符串中的格式控制标记
      • 3、python字符串格式化符号:
      • 4、字段格式化
    • 3、 f-string字面量格式化
  • 七、基本运算符
    • 1、 算术运算符
    • 2、 逻辑运算符(运算符中优先级最低,即最后运算)
    • 3、 比较运算符
    • 4、 赋值运算符
    • 5、 身份运算符,比较两个对象的存储单元。
    • 6、 位运算符
    • 7、 成员运算符
    • 8、 运算符优先级(略)
    • 9、 解压缩
  • 八、流程控制
    • 1、 if判断
    • 2、 while循环
    • 3、for循环
  • 九、range()函数
    • 实例:
  • 十、pass 语句

一、执行Python程序的两种方式

1、交互式

在终端内输入“python3”,然后输入python代码

2、命令行式

在终端内输入“python3 文本文件路径”

二、变量

1、变量的组成

Python 中的变量不需要声明。每个变量在使用前都必须赋值,变量赋值以后该变量才会被创建。

在 Python 中,变量就是变量,它没有类型,我们所说的"类型"是变量所指的内存中对象的类型。

等号(=)用来给变量赋值。

等号(=)运算符左边是一个变量名,等号(=)运算符右边是存储在变量中的值。

变量名 = 变量值。

变量名是用来接收变量值的

name = 'nick' 
age = 19

2、变量名的定义规范

  • 变量名具有某种意义
  • 由数字/字母/下划线组成,且不能由数字和下划线开头
  • 不能用Python关键字

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

3、定义变量的两种方式

  • 驼峰体:NameOfNick
  • 下划线:name_of_nick(推荐)

4、常量

常量是约定俗成的一种规范,常量名的定义方式为全大写。实际上可以被修改。

AGE_OF_NICK = 19
print(AGE_OF_NICK)

三、Python变量内存管理

1、引用计数

变量值的引用次数

x = 257  # 257的引用计数为1
y = x   # 257的引用计数为2
del x  # 257的引用计数为1

2、垃圾回收机制

当变量值的引用计数为0的时候,该变量值会被Python自动回收它的内存占用

3、小整数池

[-5,256]之间的整数会在Python解释器启动的时候,自动开辟一块内存存入这些整数.也就是说这些小整数不会因为引用计数为0而被删除。

4、内存地址与数据类型

获取变量的id,可以理解成变量在内存中的地址 。

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

结果:

10 
8790885504960 
< class 'int'>

5、实例:

id相等的变量,值一定相等,因为指向的是同一个内存地址;

值相等的变量,id不一定相等。

x = 11
y = x
z = 11
print(x == y)  # True
print(x is y)  # True
print(x is z)  # True,整数池的原因

x = 255
z = 255
print(id(x) is id(z) )  # False

四、花式赋值

1、 链式赋值

以下实例,创建一个整型对象,值为 10,从后向前赋值,三个变量被赋予相同的数值。

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

2、 交叉赋值

# 交叉赋值
x = 10
y = 20

x, y = y, x
print(x, y) #20 10

# 相当于使用临时变量
x = 10
y = 20

temp = x
x = y
y = temp

print(x, y) #20 10

3、多个变量赋值

您也可以为多个对象指定多个变量。例如:

a, b, c = 1, 2, "runoob"

以上实例,两个整型对象 1 和 2 的分配给变量 a 和 b,字符串对象 "runoob" 分配给变量 c。

写一个斐波纳契数列 Fibonacci series:

# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 10:
    print(b, end=',')
    a, b = b, a+b
# 1,1,2,3,5,8,

五、与用户交互

name = input('请输入你的姓名:')
pwd = input('请输入你的密码:')

print(type(name))
print(type(pwd))

# 请输入你的姓名:a
# 请输入你的密码:1
#
# 'str'>

无论我们输入的值是数字类型、字符串类型、列表类型,input的接收值都是字符串类型。

六、格式化输出

1、 占位符(旧式字符串格式化,逐步淘汰)

  • %s:接收任意数据类型的数据
  • %d:接收数字类型的数据
name = 'nick'
age = 19
print('my name is %s my age is %d' % (name, age))
# my name is nick my age is 19

2、 format格式化

  • {}:接收任意数据类型的数据。

1、格式:<模板字符串>.format(<逗号分隔的参数>)

name = 'nick'
age = 19
#1、括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。
print("Hello, {}. You are {}.".format(name, age)) # Hello, nick. You are 19.

2、在括号中的数字用于指向传入对象在 format() 中的位置
print("Hello, {1}. You are {0}-{0}.".format(age, name)) # Hello, nick. You are 19-19.

3、如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。
print("Hello, {name}. You are {age}-{age}.".format(age=age, name=name))# Hello, nick. You are 19-19.

4、位置及关键字参数可以任意的结合:
print('站点列表 {0}, {1}, 和 {other}。'.format('Google', 'Runoob', other='Taobao'))

2、模板字符串中的格式控制标记

{<参数序号> : <格式控制标记>}

: <填充> <对齐> <宽度> <,> <.精度> <类型>

引导

符号

填充的单个字符 <: 左对齐 
>: 右对齐 
^: 居中对齐
槽设定的输出宽度 数字的千位分隔符
浮点数小数

或 字符串最大输出长度

  • 整数类型 :b(二进制),c,d,o,x,X
  • 浮点数类型:e,E,f,%(百分数)

3、python字符串格式化符号:

  • %c: 格式化字符及其ASCII码
  • %s: 格式化字符串
  • %d: 格式化整数
  • %u: 格式化无符号整型
  • %o: 格式化无符号八进制数
  • %x: 格式化无符号十六进制数
  • %X: 格式化无符号十六进制数(大写)
  • %f: 格式化浮点数,可指定小数点后的精度
  • %e: 用科学计数法格式化浮点数
  • %E: 作用同%e,用科学计数法格式化浮点数(大写)
  • %g: %f和%e的简写
  • %G: %f 和 %E 的简写
  • %p: 用十六进制数格式化变量的地址
print("{0: =^20 }".format("PYTHON"))  # '=======PYTHON=======' 使用等号,居中对齐
print("{0: *>20 }".format("BIT"))  # '*****************BIT' 使用星号,文字右对齐
print("{:10}".format("BIT"))  # 'BIT       ' 总长度为10,不足以空格补足。在:后传入一个整数, 可以保证该域至少有这么多的宽度。 用于美化表格时很有用。
print("{0: ,.2f}".format(12345.6789))  # '12,345.68' 使用千分符,同时保留到小数点后两位
print("{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425))  # '110101001,Ʃ,425,651,1a9,1A9'
print("{0:e},{0:E},{0:f},{0:%}".format(3.14))  # '3.140000e+00,3.140000E+00,3.140000,314.000000%'

可以使用 bin,oct,hex 可输出数字的二进制,八进制,十六进制形式,例如:

a = 0b111100
print(bin(a))
# '0b111100'
print(oct(a))
# '0o74'
print(hex(a))
# '0x3c'

4、字段格式化

字典, 然后使用方括号 [] 来访问键值 :

table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
print('{0[Runoob]:d}; {0[Google]:d}; {0[Taobao]:d}'.format(table))
# 2; 1; 3

也可以通过在 table 变量前使用 ** 来实现相同的功能:

table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
print('{Runoob:d}; {Google:d}; {Taobao:d}'.format(**table))
# 2; 1; 3

3、 f-string字面量格式化

f-string 是 python3.6 之后版本添加的,称之为字面量格式化字符串,是新的格式化字符串的语法。

在字符串前面加上f或F,后面跟着字符串,字符串中的表达式用大括号 {} 包起来,它会将变量或表达式计算后的值替换进去。

用了这种方式明显更简单了,不用再去判断使用 %s,还是 %d。

name = "nick"
age = 19
print(F"Hello, {name}. You are {age}.")#Hello, nick. You are 19.

print(f'{age*2}')#38
salary = 6.6666
print(f'{salary:.2f}')#6.67

w = {'name': 'Runoob', 'url': 'www.runoob.com'}
print(f'{w["name"]}: {w["url"]}')
# 'Runoob: www.runoob.com'

在 Python 3.8 的版本中可以使用 = 符号来拼接运算表达式与结果:

x = 1
print(f'{x+1}')   # Python 3.6
# 2

x = 1
print(f'{x+1=}')   # Python 3.8
# 'x+1=2'

七、基本运算符

1、 算术运算符

+、 - 、* 、/ 、 //、 % 、**

# 除
print(10 / 3)  # 3.3333333333333335

# 除,只取整数部分
print(10 // 3)  # 3
print(10 // 4)  # 2

# %:取余
print(10 % 3)  # 1

# **,幂
print(10 ** 3)  # 1000

2、 逻辑运算符(运算符中优先级最低,即最后运算)

and、 or、 not 。

优先级:not>and>or

# 从左到右的方式找到逻辑运算符,找到逻辑运算符的左边,左边成立,再去找到逻辑运算符的右边
print(3 > 3 and 1 > 2 or 2 > 1)  # False

3、 比较运算符

>、 >=、 <、 <=、 ==、 !=(Pyhton3 已不支持 <> 运算符,可以使用 != 代替)

4、 赋值运算符

=、 +=、 -=、 *=、 /=、 //=、 **=、 %=、:=(海象运算符,可在表达式内部为变量赋值。Python3.8 版本新增运算符。)

5、 身份运算符,比较两个对象的存储单元。

is、 is not

is和==的区别:

  • is:用于判断两个变量引用对象是否为同一个(是否在同一块内存空间中),
  • ==:用于判断引用变量的值是否相等。

6、 位运算符

  • & : 按位与运算符
  • | : 按位或运算符
  • ^: 按位异或运算符
  • ~ : 按位取反运算符
  • <<: 左移动运算符
  • >> : 右移动运算符
a = 60  # 60 = 0011 1100
b = 13  # 13 = 0000 1101
c = 0

c = a & b
print( c)# 12 = 0000 1100
c = a | b
print(c)# 61 = 0011 1101
c = a ^ b
print( c)# 49 = 0011 0001
c = ~a
print( c)# -61 = 1100 0011
c = a << 2
print(c)# 240 = 1111 0000
c = a >> 2
print(c)# 15 = 0000 1111

7、 成员运算符

in、 not in

包括字符串,列表或元组等

a = 10
b = 20
list = [1, 2, 3, 4, 5]

print(a in list) # false

8、 运算符优先级(略)

如果需要某个运算符优先运算,则加个括号,使用a and b is c == d的是傻逼

9、 解压缩

hobby_list = ['read','run','sleep','fishing','piao']

# 如果取第2-3个爱好
_,hobby2,hobby3,*_ = hobby_list

print(hobby2, hobby3) #run sleep

字典也是可以的,但是字典解压缩的是key。

info = {'name': 'nick', 'age': 18}
x, y = info
print(x, y) #name age

八、流程控制

1、 if判断

Python 中用 elif 代替了 else if,所以if语句的关键字为:if – elif – else

注意:

  • 1、每个条件后面要使用冒号 :,表示接下来是满足条件后要执行的语句块。
  • 2、使用缩进来划分语句块,相同缩进数的语句在一起组成一个语句块。
  • 3、在Python中没有switch – case语句。
# if
if 条件:
    代码块

# if...else
if 条件:
    代码块
else:
    代码块

# if...elif....elif...else
if 条件:
    代码块
elif 条件:
    代码块
elif 条件:
    代码块

...(可以写任意个elif)

else:
    代码块

2、 while循环

同样需要注意冒号和缩进。另外,在 Python 中没有 do..while 循环。

#while
while 条件:
    代码块

#while + break
while 条件:
    代码块
    break  # 结束本层循环,跳出循环

# while + continue
while 条件:
    代码块
    if 条件:
        代码块
        cotinue  # 不执行下面代码,然后继续循环,即跳出本次循环
    代码块

#while + else
while 条件:
    代码块
else:
    print('如果我没有被break,我就会被打印出来')

实例:

n = 1
while n < 4:
    print(n)
    n += 1
else:
    print("a")
# 1,2,3,a

使用循环嵌套来实现99乘法法则:

# 外边一层循环控制行数
# i是行数
i = 1
while i <= 9:
    # 里面一层循环控制每一行中的列数
    j = 1
    while j <= i:
        mut = j * i
        print("%d*%d=%d" % (j, i, mut), end="  ")
        j += 1
    print("")
    i += 1
# 1*1=1
# 1*2=2  2*2=4
# 1*3=3  2*3=6  3*3=9
# 1*4=4  2*4=8  3*4=12  4*4=16
# 1*5=5  2*5=10  3*5=15  4*5=20  5*5=25
# 1*6=6  2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
# 1*7=7  2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
# 1*8=8  2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
# 1*9=9  2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81

3、for循环

for循环可以遍历任何序列的项目,如一个列表或者一个字符串。

for循环的循环次数受限于容器类型的长度,而while循环的循环次数需要自己控制。

#for
for i in range/str/list/tuple/dict/set(可迭代对象):
    print(i)

#for + break
for i in range/str/list/tuple/dict/set(可迭代对象):
    print(i)
    break  # 结束本层循环

# for + continue
for i in range/str/list/tuple/dict/set(可迭代对象):
    print(i)
    if 条件:
        continue  # 结束本次循环,即不执行下面代码,继续循环
    代码块

#for + else
for i in range/str/list/tuple/dict/set(可迭代对象):
    print(i)
else:
    print('如果我没有被break,我就会被打印出来')

实例:

# for循环按照索引取值

name_list = ['nick', 'jason', 'tank', 'sean']
for i in range(len(name_list)):
    print(i, name_list[i])

# 0 nick
# 1 jason
# 2 tank
# 3 sean

九、range()函数

如果你需要遍历数字序列,可以使用内置range()函数。它会生成数列,例如:

for i in range(5):
    print(i)
# 0 1 2 3 4

你也可以使用range指定区间的值:

for i in range(5, 9):
    print(i)
# 5 6 7 8

也可以使range以指定数字开始并指定不同的增量(甚至可以是负数,有时这也叫做'步长'):

for i in range(0, 10, 3):
    print(i)
#   0 3 6 9

负数:

for i in range(-10, -100, -30):
    print(i)
# -10 -40 -70

您可以结合range()和len()函数以遍历一个序列的索引,如下所示:

a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
for i in range(len(a)):
    print(i, a[i])
# 0 Google 1 Baidu 2 Runoob 3 Taobao 4 QQ

还可以使用range()函数来创建一个列表:

a = list(range(5))
print(a)
# [0, 1, 2, 3, 4]

实例:

1-100 的和:

print(sum(range(101)))

十、pass 语句

Python pass是空语句,是为了保持程序结构的完整性。

pass 不做任何事情,一般用做占位语句,如下实例

while True:
    pass  # 等待键盘中断 (Ctrl+C)

最小的类:

class MyEmptyClass:
    pass

到此这篇关于Python变量流程基础的文章就介绍到这了。希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • python字符串运算符详情

    知识点:字符串 在编程里,用的最多的就是字符串,字符串同时也是各类数据的中转站 ​字符串运算符:​ 编号 运算符类型 说明 1 + 字符串拼接 2 * 同一字符串多次输出 3 [] 通过下标获取字符串其中一个字符 ​代码如下:​ #!/usr/bin/python3 # -*- coding: utf-8 -*- import random # 字符串连接运算 myStr_a1='51' myStr_a2='cto' myStr=myStr_a1+myStr_a2 print('字符串:'+my

  • python类名和类方法cls修改类变量的值

    通过类对象是无法修改类变量的值的,本质其实是给类对象新添加 name 和 age 这 2 个实例变量.不会影响类的其它实例化对象,更不会影响同名的类变量. 和类变量不同,实例变量只能通过类对象名访问,无法通过类名访问. 通过cls和类名修改类变量的值,会修改同名的类变量,会影响所有的实例化对象 class Person:     name='jerry'     age='20'     def __init__(self, name, age):         self.name = nam

  • python中常见的运算符及用法实例

    目录 前言 算术运算符 关系运算符 逻辑运算符 成员运算符 身份运算符 三目运算符 运算符优先级 总结 前言 python中的运算符主要包括算术运算符,关系(比较)运算符,赋值运算符,逻辑运算符,成员运算符,身份运算符,三目运算符.使用运算符将不同类型的数据按照一定的规则连接起来的式子,称为表达式.下面将介绍一些常用的运算符 算术运算符 运算符 描述 + 两个数相加两个数相加,或是字符串连接 - 两个数相减 * 两个数相乘,或是返回一个重复若干次的字符串 / 两个数相除,结果为浮点数 % 取模,

  • python中的各种运算符介绍

    目录 一.比较运算符 二.​赋值运算符​ ​三.位运算符​ 四.​逻辑运算符​ 五.​成员运算符​ 以Python 3.x版本为主 一.比较运算符 比较运算符主要是True和Fals两个值 编号 比较运算符 说明 1 == 等于 2 != <>(Python3 已不再使用) 不等于 3 > 大于 4 < 小于 5 >= 大于等于 6 <= 小于等于 ​代码如下:​ a=51 b=len('CTO') # 等于 print('a和b等于比较值:'+str(a==b)) #

  • python的运算符与表达式你真的了解吗

    目录 一.表达式 二.运算符 1.算术运算符 2.赋值运算符 3.比较运算符 4.逻辑运算符 5.成员关系运算 6.对象实例测试 7.位运算 8.一元运算 : 三.python运算符优先级 1.运算符优先级 2.计算顺序 总结 一.表达式 是由一个或多个操作数通过操作符组合而成 最简单的表达式仅包含一个字面值常量或变量 二.运算符 1.算术运算符 运算符 描述(变量a为10,变量b为21) 实例 + 加:两个对象相加 a+b 输出:31 - 减:得到负数或是一个数减去另一个数 a-b 输出:-1

  • Python中的变量及简单数据类型应用

    目录 一.变量 二.字符串 1.使用方法修改字符串的大小写 2.在字符串中添加空白 3.删除空白 三.数字 1.整数 2.浮点数 3.使用函数str()避免类型错误 四.Python 之禅 前言: 本文的主要内容是介绍Python中的变量命名规则和简单数据类型的应用,简单的数据类型包括字符串和数字等,文中还附有代码以及相应的运行结果辅助理解. 一.变量 变量的命名规则: 1.变量名只能包含字母.数字和下划线,且数字不能打头. 2.变量名不能包含空格,但可使用下划线来分隔其中的单词. 3.不要将P

  • python流程控制

    目录 1. 布尔逻辑 1.1 条件控制语句-if 1.2 if/else 语句 1.3 if/elif 语句 2 循环控制语句 2.1 循环控制之for 2.2 循环控制之while 3 for vs while 3.1 对输入的数字求和 3.2 未知个数字的求和 3.3 阶乘计算 前言: 经过简单的了解python基本语法和使用后,发现其都是一些顺序执行语句,也就是依次执行,没有任何的分支,循环,也不会返回到以前的执行语句-流程控制.在实际使用中,当然不可避免使用到流程控制语句,但其都要由逻辑

  • Python执行流程控制 详情

    目录 一 引子 二 分支结构 2.1 什么是分支结构 2.2 为什么要用分支结构 2.3 如何使用分支结构 2.3.1 if语法 2.3.2 if应用案例 三 循环结构 3.1 什么是循环结构 3.2 为什么要用循环结构 3.3 如何使用循环结构 3.3.1 while循环语法 3.3.2 while循环应用案例 3.3.3 for循环语法 3.3.4 for循环应用案例 一 引子 流程控制即控制流程,具体指控制程序的执行流程,而程序的执行流程分为三种结构:顺序结构(之前我们写的代码都是顺序结构

  • Python中的流程控制详解

    流程控制无非就是if else之类的控制语句,今天我们来看一下Python中的流程控制会有什么不太一样的地方. while语句 python中的while语句和其他语言没有什么不一样,我使用while语句来编写一个斐波拉赫数列: In [56]: while x < 10 : ...: print(x) ...: x, y = y, x+y ...: 0 1 1 2 3 5 8 if 语句 python中的 if 可以和 elif 或者 else 配合使用: >>> x = int

  • Python程序流程控制实验

    1. 编写程序计算 1+3+5+7…+99 之和. sum=0 for i in range(1,100,2):     sum+=i print(sum) 2. 编写程序,计算 2+4+6+8…+100 之和. sum=0 for i in range(2,101,2):     sum+=i print(sum) 3. 编写程序,使用不同的实现方法输出 2000~3000 的所有闰年,运行效果如下图所示. num=0 for i in range(2000,3001):     if (i%

  • 分享几种python 变量合并方法

    目录 一.list 合并 二.str 合并 三.dict 合并 一.list 合并 第一种方法: a =[91,95,97,99] b =[92,93,96,98] c = a+b  # 合并 c.sort()  # 排序  正序 print(c) c.sort(reverse=True)  # 排序  倒序 print(c) 第二种方法: a =[91,95,97,99] b =[92,93,96,98] a[0:0] = b # 合并 a.sort() print(a) 第三种方法: a =

  • Python 6种基本变量操作技巧总结

    目录 前言 变量赋值 变量类型 对象引用 对象身份 变量名 保留字(关键字) 前言 看到这里已经学习了创建各种 Python 数据类型的值.并且显示的值都是文字或常量值. >>> print(9.98) 9.98 但是对于复杂代码的情况需要下,程序需要对应的数值随着代码的变化而变化的情况并且进行更改. 可以 Python 程序中的每一项数据如何可以用抽象术语object来描述,使用称为variables的符号名称来操作对象 变量赋值 将变量视为附加到特定对象的名称.在 Python 中,

  • Python中的程序流程控制语句

    目录 一.分支语句 二.循环语句 1.可迭代对象 2.while循环 3.for循环 4.九九乘法表 三.循环控制语句 1.break 2.continue 3.goto 4.else 四.循环相关的内置函数 1.enumerate() 2.zip() 3.map() 五.总结 前言: 本篇博客将会讲述一下Python语言中的流程控制语句,在高中我们数学中学过程序流程题,达到一个目的往往需要从开始一步一步往下走,有时顺序执行.有时面临选择.有时面临循环.循环与选择控制着整个流程.看到下面的图片是

随机推荐