亲宝软件园·资讯

展开

Python变量与数据类型

礁之 人气:1

一、 Python变量与数据类型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mJOL9YdR-1644998906579)(F:\个人文档\markdown图片\image-20210612104335264.png)]

1.变量概述

变量是存储在内存中的值,而这就意味着在创建变量时会在内存中开辟一个空间。基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中,因此,变量可以指定不同的数据类型

变量名是由字母、数字、下划线组成的,第一个字符必须是字母或者下划线_

使用变量可以提高代码的可读性,便于修改

Python中的变量赋值不需要类似声明,每个变量都在内存中创建,包括变量的的标识、名称、数据等信息,每个变量在使用前都必须赋值,变量赋值以后这个变量才会被创建

在Python中“=”用来给变量赋值,变量名=变量值

2.创建变量

#创建合法的变量名称
>>> a =1 
>>>print(a)  #print()是打印,即shell中的echo
1
>>> _a =2
>>> print(_a)
2
>>> a1 = 3
>>> print(a1)
3

#可以同时指定多个变量名进行赋值
>>> a,b,c = 1,2,3
>>> print(a)
1
>>> print(b,c)
2 3

3.Python3常用的数据类型

类型作用
数字(Numbers)数字类型数据用于存储数值,他们是不可改变的数据类型,这意味着改变数字类型会分配一个新的对象,当你指定一个值时,Numbers类型的对象就会被创建
字符串(String)字符串或串是由数字、字母、下划线组成的一串字符,在给变量赋值时加双引号就是字符串类型
列表(List)Python中使用最频繁的数据类型,列表可以完成大多数集合类的数据结构,支持字符、数字、字符串,也可以嵌套,在列表中包含列表,使用[ ]创建列表
元组(Tuple)元组是另一个数据类型,类似于列表,但是不能二次赋值,相当于只读列表,使用()创建元组
字典(Dictionary)字典是除了列表以外,Python中最灵活的内置数据结构类型,使用{ }创建字典

列表是有序的对象集合,而字典是无序的对象集合。两者的区别在于,字典中的元素是通过键来存取的,也就是键值对的方式Key-Value,而不是通过偏移存取。列表只是简单的存放多个变量值,字典相当于是”在字典中又创建了变量“

3.1.数字(Numbers)

3.1.1.数字的数据类型也分成了很多种类型:

整型(int): 也就是整数

浮点型(float): 带小数点的数字

布尔型(bool): 用于逻辑运算,只有true和false,即真和假

复数(complex): 复数由实部(real)和虚部(imag)构成,在 Python 中,复数的虚部以j或者J作为后缀,,如1+2j、1.1+2.2J

3.1.2.Python运算符:

算法运算符
加法+
减法-
乘法*
除法/
求模,取余%
求幂,即求次方,2**2即2的2次方**

先乘除后加减,有小括号就先算小括号,注意:Python是不支持自增运算符++和自减运算符–的

3.1.3.整型、浮点型、布尔型

>>> x = 123   #整型
>>> print(x)
123
>>> y = 1.12  #浮点型
>>> print(y)
1.12
>>> a = True  #布尔型true
>>> print(a)
True
>>>if(a):  #使用if语句反段,符合if语句的条件,就输出下面的语句,因为a为布尔型true,所以始终为真,也就是始终符合条件
...    print("为真")
...    
为真
>>> b = False #布尔型false
>>> if(b):  #如果b符合条件,则输出为真,否则输出为假,因为b是布尔型false,所以始终为假,也就是始终为假
...    print("为真")
... else:    
...    print("为假")
...   
为假

3.1.4.变量标识符

变量标识符就像是变量的“SFZ”,具有唯一性

>>> print(id(x))  #查看x变量的标识符
2774440106160

>>> print(id(y))  #查看y变量的标识符
2774486777776

3.1.5.Python运算符

>>> x,y = 2,4     #赋值变量x和y的值分别是2和4
>>> print(x+y,y-x,x*y)  #加、减、乘算法
6 2 8

>>> print(4/2,2**4)  #除、求幂算法
2.0 16

>>> print(8%5)  #取余算法,8除5余3
3

3.2.字符串(String)

  1. python中单引号和双引号使用完全相同。
  2. 使用三引号(’’’ 或 “”")可以指定一个多行字符串。
  3. 转义符 \
  4. 反斜杠可以用来转义,使用r可以让反斜杠不发生转义。。 如 r"this is a line with \n" 则\n会显示,并不是换行。
  5. 按字面意义级联字符串,如"this " "is " "string"会被自动转换为this is string。
  6. 字符串可以用 + 运算符连接在一起,用 * 运算符重复。
  7. Python 中的字符串有两种索引方式,从左往右以 0 开始,从右往左以 -1 开始。
  8. Python中的字符串不能改变。
  9. Python 没有单独的字符类型,一个字符就是长度为 1 的字符串。

3.2.1.单引号、双引号、三引号

>>> name = '亚索'  #单引号
>>> print(name)
亚索

>>> age = "34岁"   #双引号
>>> print(age)
34岁
>>> aihao = """    #三引号
耍剑
喝酒
"""
>>> print(aihao)

3.2.2.转义符

>>> aaa = "aa'gao'"   
>>> print(aaa)
aa'gao'
>>> bbb = ' aaa"ccc"'
>>> print(bbb)
 aaa"ccc"
>>> ccc = 'abc\'ccc' #转义'为普通字符
>>> print(ccc)
abc'ccc

3.2.3.常用转义符

转义符作用
\在行尾时使用,为续航符,也就是换行符
\\这个含义是指把\转义成普通字符
\’把’转义成普通字符
\"把“转义成普通字符
\n换行符,把光标移动到下一行继续
\v纵向制表符,将光标向下移动一个制表符单位
\t水平制表符,将光标向右移动一个制表符单位
\r代表一个回车

3.2.4.字符串的其他用法

#+号可以当作字符串的连接字符,而*号可以是重复操作
>>> print("aaa" + "bbb")
aaabbb
>>> print(3*"aaa")
aaaaaaaaa

#新建一个新的.py文件,写入:
a = ' '
print("欢迎来到,英雄联盟")
print(a*2+"欢迎来到,英雄联盟")
print(a*4+"欢迎来到,英雄联盟")
欢迎来到,英雄联盟
  欢迎来到,英雄联盟
    欢迎来到,英雄联盟
#a为一个空,利用*号可以使空重复操作变成多个,然后就可以实现上面的效果

3.3.列表(list)

3.3.1.列表的定义

#列表其实就是一个变量有多个变量值,但是这个变量值叫做元素,所以也叫做,一个列表中有多个元素,使用[]来表示列表
>>> a = ["1","2","3"]
>>> print(a)
['1', '2', '3']

3.3.2列表的取值

#列表有两种取值顺序:
1.从左到右索引默认从0开始,最大范围是字符串长度-1,这个0和shell的位置变量有点像
2.从右到左的索引默认从-1开始,最大范围是字符串开头
>>> a = ["1","2","3"]
>>> print(a)
['1', '2', '3']
>>> print(a[0])
1
>>> print(a[1])
2
>>> print(a[2])
3
>>> print(a[-1])
3
>>> print(a[-2])
2
>>> print(a[-3])
1
>>> print(a[0:2])   #从0开始到2位置结束
['1', '2']
>>> print(a[0:3])
['1', '2', '3']
>>> print(a[0:1])
['1']
>>> a[0]=4   #修改a列表中0位置为4
>>> print(a)  
[4, '2', '3']
>>> a.append(5)  #在a列表末尾添加5
>>> print(a)
[4, '2', '3', 5]
>>> a.insert(1,6)  #在a列表的1位置后添加6
>>> print(a)
[4, 6, '2', '3', 5]

3.3.3.删除列表元素

>>> print(a)
[4, 6, '2', '3', 5]
>>> del a[0]    #删除a列表中的0位置的元素
>>> print(a)
[6, '2', '3', 5]

3.3.4.查找列表元素

>>> print(a)
[6, '2', '3', 5]
>>> 6 in a      #查看a列表中是否有6,有就返回True没有就返回False
True
>>> 8 in a
False

3.3.5.合并列表

>>> a = ["nihao","shijie"]
>>> b = ["hello","world"]
>>> c = a + b   #利用+号,来合并列表,变量也可以这样使用
>>> print(c)
['nihao', 'shijie', 'hello', 'world']
>>> d = b + a
>>> print(d)
['hello', 'world', 'nihao', 'shijie']
>>> print(a*3)   #利用*号,来重复列表
['nihao', 'shijie', 'nihao', 'shijie', 'nihao', 'shijie']

3.3.6.列表常见问题

>>> print(a)
[1, 2, 3]
>>> print(a[6])     #不能直接查看超过列表元素总数的值
Traceback (most recent call last):
  File "<input>", line 1, in <module>
IndexError: list index out of range
>>> print(a[1:6])    #但是可以指定范围查看
[2, 3]
>>> print(a[0:-1])   #指定范围时,可以同时使用正数和负数进行索引
[1, 2]

3.3.7.嵌套列表

#列表中也可以是列表,是可以无限嵌套的
>>> a = [[1,2,3],"aaa",[4,5,6]]
>>> print(a)
[[1, 2, 3], 'aaa', [4, 5, 6]]
>>> print(a[0])  #查看a列表中的第0个位置的元素
[1, 2, 3]
>>> print(a[0][0])  #查看a列表中第0个位置元素的第0个位置的元素
1

3.3.8.字符串转列表

str1 = "12345"
list1 = list(str1)
print list1

str2 = "123 sjhid dhi"
list2 = str2.split() #or list2 = str2.split(" ")  #以“空”为分割来切割字符串生成列表
print list2

str3 = "www.google.com"
list3 = str3.split(".")  #以“.”为结果分割
print list3

结果如下:

['1', '2', '3', '4', '5']
['123', 'sjhid', 'dhi']
['www', 'google', 'com']

3.3.9.反转列表元素

a=[1,2,3,4]
b=a[-1::-1]   #第一个-1表示从4开始,::表示移动到列表末尾,也就是移动到1,第二个-1表示逆向
print(b)

#输出结果
[4, 3, 2, 1]

3.4.元组(Tuple)

元组类似于一个只读列表,写入元素后,元组中的元素是不可变的,操作速度比列表要快,安全性更强,使用()来创建元组

虽然tuple的元素不可改变,但它可以包含可变的对象,比如list列表。

构造包含 0 个或 1 个元素的元组比较特殊,所以有一些额外的语法规则:

tup1 = ()    # 空元组
tup2 = (20,) # 一个元素,需要在元素后添加逗号

3.4.1元组的创建和删除

>>> a = (1,2,3)
>>> print(a)
(1, 2, 3)
>>> a[0] = 4  #元组的元素不能修改,会报错
Traceback (most recent call last):
  File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>> del a    #在删除元组时,只能全部删除,不能指定删除某个元素
>>> print(a)
Traceback (most recent call last):
  File "<input>", line 1, in <module>
NameError: name 'a' is not defined

3.4.2.元组和列表的互相转换

>>> a = [1,2,3]
>>> b = (1,2,3)
>>> c = list(b)  #转换时,需要重新定义变量
>>> print(c)
[1, 2, 3]
>>> print(type(c))  #查看c变量的类型,发现是列表
<class 'list'>
>>> d = tuple(a)  #把a列表变成元组,并且重新定义变量成d
>>> print(d)
(1, 2, 3)
>>> print(type(d))
<class 'tuple'>

3.5.集合(Set)

集合是由一个或数个形态各异的大小整体组成的,构成集合的事物或对象称作元素或是成员

基本功能是进行成员关系测试和删除重复元素

可以使用大括号{ }或者是set( )函数创建集合,要注意的是,创建一个空集合必须使用set( ),因为{ }使用来创建一个空字典的

创建格式:

a = {value1,value2,...}
set(value)

3.5.1.集合的创建

a = {'aaa','bbb','ccc','ddd'}
print(a)
print(type(a))

输出结果:
{'aaa', 'ddd', 'bbb', 'ccc'}
<class 'set'>
b=set("aaaa5cccddd")
print(b)
print(type(b))

输出结果:
{'a', 'd', 'c', '5'}
<class 'set'>

3.5.2.成员测试

a = {'aaa','bbb','ccc','ddd'}
if 'aaa' in a:
    print("aaa在a集合中")
else:
    print("aaa不在a集合中")
    
输出结果:
aaa在a集合中

3.5.3.集合运算

a = set('abracadabra')
b = set('alacazam')
print(a)
print(b)
print(a - b)   #a和b的差集
print(a | b)   #a和b的并集
print(a & b)   #a和b的交集
print(a ^ b)   #a和b中不同时存在的元素

输出结果:
{'b', 'r', 'd', 'c', 'a'}
{'l', 'z', 'm', 'c', 'a'}
{'r', 'd', 'b'}
{'l', 'z', 'b', 'r', 'd', 'm', 'c', 'a'}
{'a', 'c'}
{'l', 'r', 'z', 'b', 'd', 'm'}

3.6.字典(Dictionary)

字典中的值,是通过键值对来存储的,key-value的方式,使用{}来创建字典,字典的索引由键和它对应的值组成

列表是有序的对象集合,字典是无序的对象集合。两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。

字典是一种映射类型,字典用 { } 标识,它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中,键(key)必须是唯一的。创建字典使用{ }

3.6.1.字典的创建

#字典中的键具有唯一性,但是值可以相同,键名区分大小写,当有多个相同的键名和值时,只有最后一个键值会生效
>>> a = {"id":1,"name":"zhangsan"}
>>> print(a)
{'id': 1, 'name': 'zhangsan'}
>>> print(type(a))
<class 'dict'>
>>> print(a["id"])  #索引a字典中,id键的值
1
>>> print(a["name"])
zhangsan
>>> a = {"id":1,"id":2,"id":3} 
>>> print(a)  #字典中有多个相同的键时,只有最后一个键值会生效
{'id': 3}
>>> del a     #删除a字典

3.6.2.字典中键的添加、修改、删除操作

#添加:
a={"aaa":1,"bbb":2}
a["ccc"] = 3   #添加不存在的键值即可
print(a)

输出结果:
{'aaa': 1, 'bbb': 2, 'ccc': 3}
——————————————————————————————
#修改:
a={"aaa":1,"bbb":2}
a["aaa"] = 3   #修改指定键的值
print(a)

输出结果:
{'aaa': 3, 'bbb': 2}
——————————————————————————————
#删除:
a={"aaa":1,"bbb":2}
del a["aaa"]    #删除指定的键值
print(a)

输出结果:
{'bbb': 2}

3.7.Python数据类型转换

有时候,我们需要对数据内置的类型进行转换,数据类型的转换,你只需要将数据类型作为函数名即可。

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象,表示转换的值。

函数描述\作用
int(x [,base])将x转换为一个整数
float(x)将x转换到一个浮点数
complex(real [,imag])创建一个复数
str(x)将对象 x 转换为字符串
repr(x)将对象 x 转换为表达式字符串
eval(str)用来计算在字符串中的有效Python表达式,并返回一个对象
tuple(s)将序列 s 转换为一个元组
list(s)将序列 s 转换为一个列表
set(s)转换为可变集合
dict(d)创建一个字典。d 必须是一个 (key, value)元组序列。
frozenset(s)转换为不可变集合
chr(x)将一个整数转换为一个字符
ord(x)将一个字符转换为它的整数值
hex(x)将一个整数转换为一个十六进制字符串
oct(x)将一个整数转换为一个八进制字符串

4.Python3基础语法

4.1.编码

默认情况下,Python 3 源码文件以 UTF-8 编码,所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码:

# -*- coding: cp-1252 -*-

上述定义允许在源文件中使用 Windows-1252 字符集中的字符编码,对应适合语言为保加利亚语、白罗斯语、马其顿语、俄语、塞尔维亚语。

4.2.标识符

在 Python 3 中,可以用中文作为变量名,非 ASCII 标识符也是允许的了。

4.3.Python保留字

保留字即关键字,我们不能把它们用作任何标识符名称。Python 的标准库提供了一个 keyword 模块,可以输出当前版本的所有关键字:

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', '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']

4.3.注释

Python中单行注释以 # 开头,实例如下:

#!/usr/bin/python3  
# 第一个注释 
print ("Hello, Python!") # 第二个注释

执行以上代码,输出结果为:

Hello, Python!

多行注释可以用多个 # 号,还有 ‘’’“”"

#!/usr/bin/python3  
# 第一个注释 
# 第二个注释  
''' 
第三注释 
第四注释 
'''  
""" 
第五注释 
第六注释 
""" 
print ("Hello, Python!")

执行以上代码,输出结果为:

Hello, Python!

4.4.行与缩进

python最具特色的就是使用缩进来表示代码块,不需要使用大括号 {}

缩进的空格数是可变的,但是同一个代码块的语句必须包含相同的缩进空格数。实例如下:

if True:    
    print ("True") 
else:    
    print ("False")

以下代码最后一行语句缩进数的空格数不一致,会导致运行错误:

if True:
  print ("Answer")
  print ("True")
else:
  print ("Answer")
 print ("False")   # 缩进不一致,会导致运行错误

以上程序由于缩进不一致,执行后会出现类似以下错误:

File "test.py", line 6
    print ("False")    # 缩进不一致,会导致运行错误
                                      ^
IndentationError: unindent does not match any outer indentation level

4.5.多行语句

Python 通常是一行写完一条语句,但如果语句很长,我们可以使用反斜杠 ** 来实现多行语句,例如:

total = item_one + \
        item_two + \
        item_three

在 [], {}, 或 () 中的多行语句,不需要使用反斜杠 ****,例如:

total = ['item_one', 'item_two', 'item_three',
        'item_four', 'item_five']

4.6.空行

函数之间或类的方法之间用空行分隔,表示一段新的代码的开始。类和函数入口之间也用一行空行分隔,以突出函数入口的开始。

空行与代码缩进不同,空行并不是Python语法的一部分。书写时不插入空行,Python解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码,便于日后代码的维护或重构。

**记住:**空行也是程序代码的一部分。

4.7.等待用户输入

执行下面的程序在按回车键后就会等待用户输入:

\#!/usr/bin/python3  
input("\n\n按下 enter 键后退出。")   #利用input交互式赋予变量值

以上代码中 ,"\n\n"在结果输出前会输出两个新的空行。一旦用户按下 enter 键时,程序将退出。

4.8.同一行显示多条语句

Python 可以在同一行中使用多条语句,语句之间使用分号 ; 分割,以下是一个简单的实例:

\#!/usr/bin/python3  
import sys; x = 'runoob'; sys.stdout.write(x + '\n')

使用脚本执行以上代码,输出结果为:

runoob

使用交互式命令行执行,输出结果为:

>>> import sys; x = 'runoob'; sys.stdout.write(x + '\n')
runoob
7

此处的 7 表示字符数。

4.9.多个语句构成代码组

缩进相同的一组语句构成一个代码块,我们称之代码组。

像if、while、def和class这样的复合语句,首行以关键字开始,以冒号( : )结束,该行之后的一行或多行代码构成代码组。

我们将首行及后面的代码组称为一个子句(clause)。

如下实例:

if expression : 
   suite
elif expression : 
   suite 
else : 
   suite

4.10.print输出

print 默认输出是换行的,如果要实现不换行需要在变量末尾加上 end=""

\#!/usr/bin/python3  
x="a" 
y="b" 
# 换行输出 
print( x ) 
print( y )  
print('---------') 
# 不换行输出 
print( x, end=" " ) 
print( y, end=" " ) 
print()

以上实例执行结果为:

a
b
---------
a b

4.11.import和from…import

在 python 用 import 或者 from…import 来导入相应的模块。

将整个模块(somemodule)导入,格式为: import somemodule

从某个模块中导入某个函数,格式为: from somemodule import somefunction

从某个模块中导入多个函数,格式为: from somemodule import firstfunc, secondfunc, thirdfunc

将某个模块中的全部函数导入,格式为: from somemodule import *

#导入sys模块
import sys 
print('================Python import mode==========================') 
print ('命令行参数为:') 
for i in sys.argv:    
    print (i) 
print ('\n python 路径为',sys.path)

#导入sys模块的argv,path成员
from sys import argv,path  #  导入特定的成员  
print('================python from import===================================') print('path:',path) # 因为已经导入path成员,所以此处引用时不需要加sys.path

4.12.命令行参数

很多程序可以执行一些操作来查看一些基本信息,Python可以使用-h参数查看各参数帮助信息:

$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d     : debug output from parser (also PYTHONDEBUG=x)
-E     : ignore environment variables (such as PYTHONPATH)
-h     : print this help message and exit

[ etc. ]

我们在使用脚本形式执行 Python 时,可以接收命令行输入的参数

二、脚本 -选车牌小程序

import random
import string      #导入变量
car_num = string.digits+string.ascii_uppercase   #定义一个变量,这个变量的值是随机的数字和大写字母组成的字符串
print("请选择你的车牌号")    #提示语
a = 3     #预定义变量用作于while循环
while a > 0:    #当a变量的值大于0时进行循环,a变量定义为3
    num_list = []  #定义一个空列表
    for i in range(20):  #定义for循环,循环20次
        choice = random.choice(string.ascii_uppercase)   #定义变量,这个变量的值是随机的一位大写字母
        car = f"京{choice}-{''.join(random.sample(car_num,5))}"  #定义变量,这个变量就是车牌号,利用join把上面变量的五位字符串整合到一起
        car = str(car)    #上面的变量定义为字符串类型
        num_list.append(car)    #把新建变量加入上面定义的空列表,加入到末尾
        print(f"这是第{i}次的车牌号:{car}")    #提示语
    aaa = input("请选择你的车牌:")    #利用交互式函数input对aaa变量进行赋值
    if aaa in num_list:      #对aaa变量进行判断输入的变量值是否在上面的列表中
        print(f"恭喜你选中车牌,车牌号是:{aaa}")    #有的话输出提示语并且退出循环
        break
    else:
        a -= 1           #没有的话利用while循环a的值进行提示
        print(f"对不起,你没有选中车牌,你还有{a}次机会")
        if a == 0:
            print("对不起,你已经无法选择车牌了")
        else:
            print("请重新选择")

-99乘法表

for a in range(1,9):
    for b in range(1,9):
        if b <= a:
            c = a * b
            print(f"{a} * {b} = {c}\t", end="")
    print("")

- 年会抽奖小程序

import random
import string
list_1 = []
for i in range(1,300):
    name_1 = string.ascii_uppercase
    name_2 = random.sample(name_1,2)
    name_3 = str(i) + ''.join(name_2)
    list_1.append(name_3)
print(list_1)

print(random.choice(list_1))
a = 1
b = 1
c = 1
while a < 4:
    while b < 7:
        while c < 31:
            san = random.choice(list_1)
            print(f"抽三等奖,奖品是byt,第{c}位抽奖的是{san},恭喜获得三等奖")
            list_1.remove(san)
            c = c + 1
        er = random.choice(list_1)
        print(f"抽二等奖,奖品是iphone,第{b}位抽奖的是{er},恭喜获得二等奖")
        list_1.remove(er)
        b = b + 1
    yi = random.choice(list_1)
    print(f"抽一等奖,奖品是泰国五日游,第{a}位抽奖的是{yi},恭喜获得一等奖")
    list_1.remove(yi)
    a = a + 1

print(list_1)

加载全部内容

相关教程
猜你喜欢
用户评论