python基础 - 变量、数据类型
Python解释器有：
字节码 机器码
1. CPython: C语言开发， 默认在官网下载安装的python就为Cpython
2. IPython: CPython之上的一个交互式解释器，但是执行Python代码的功能和CPython是完全一样的。
3. PyPy: 注重运行速度， 与CPython有些区别
4. Jpython： 运行在Java平台上的Python解释器
5. IronPython
Python字符编码
早期ASCII编码存储有127个字符，包含大小写字母， 数字和一些符号。由于世界语言众多，会出现多个字符编码，但是在多语言混合的文本中会出现乱码。因此Unicode 字符集应运而生。 Unicode把所有语言都统一到一套编码里， 解决了乱码问题。
其中ASCII编码和Unicode编码的区别：ASCII编码是1个字节，而Unicode编码通常是2个字节。
虽然Unicode解决了乱码问题， 但是存储空间却增加了。由此又出现了“可变长编码”的UTF-8编码。
UTF-8编码把一个Unicode字符根据不同的数字大小编码成1-6个字节，常用的英文字母被编码成1个字节，汉字通常是3个字节，只有很生僻的字符才会被编码成4-6个字节。
Python源代码也是一个文本文件，所以，当你的源代码中包含中文的时候，在保存源代码时，就需要务必指定保存为UTF-8编码。当Python解释器读取源代码时，为了让它按UTF-8编码读取，我们通常在文件开头写上这两行：
二、Python数据类型和变量
# python 的数据类型包括：
1. 整数： 包括负整数
2. 浮点数： 小数。 很大或者很小的浮点数，使用科学计数法，如：7.77 x 10^9 可以使用7.77e9 或者使用77.7e8
0.00012使用：1.2e-4
2. 字符串
3. 布尔值
4. list
5. 字典
。。。
python 变量
变量是任意数据类型。
变量在程序中就是用一个变量名表示了，变量名必须是大小写英文、数字和_的组合，且不能用数字开头
python在定义变量时不需要指定其类型，python解释器在定义个变量如：a = 'abc' 时做了两件事：
1. 在内存中创建了一个'abc'字符串；
2. 在内存中创建了一个名为a的变量， 并把它指向'ABC'
python 常量: 不能变的量
在Python中，通常用全部大写的变量名表示常量：
PI = 3.1415926
三、输入输出
3.1 输出
python使用print()函数进行输出如：
print("Hello python %s" % pa)
python的格式化输出：
print('%2d-%02d' % (3, 1))
print('%.2f' % 3.1415926)
print("Name is: %s:" % name)
s1 = "%s language" % "Python" ##结果：Python language
s2 = "percent %.5f %%" % 99.8999333121 ##结果：percent 99.89993 %
s3 = "My name is %(name)s age %(age)d" % {"name":"xiaoming","age":20} ##结果： My name is xiaoming age 20
s4 = "your record is %(record).2f" %{"record": 98.922} ##结果：your record is 98.92
s5 = "Linux %+20s language" % "Python" ##结果：Linux Python language
s6 = "Linux %-20s language" % "Python" ##结果：Linux Python language
"Linux \033[32;11m%s\033[0m language" % "Python" #还可以添加颜色
python 字符串格式化符号:
| 描述 | |
|---|---|
| %c | 格式化字符及其ASCII码 |
| %s | 格式化字符串 |
| %d | 格式化整数 |
| %u | 格式化无符号整型 |
| %o | 格式化无符号八进制数 |
| %x | 格式化无符号十六进制数 |
| %X | 格式化无符号十六进制数（大写） |
| %f | 格式化浮点数字，可指定小数点后的精度 |
| %e | 用科学计数法格式化浮点数 |
| %E | 作用同%e，用科学计数法格式化浮点数 |
| %g | %f和%e的简写 |
| %G | %F 和 %E 的简写 |
| %p |
格式化操作符辅助指令:
| 功能 | |
|---|---|
| * | 定义宽度或者小数点精度 |
| - | 用做左对齐 |
| + | 右对齐：在正数前面显示加号( + ) |
| <sp> | 右对齐：在正数前面显示空格，负数前面加负号 |
| # | 在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X') |
| 0 | 显示的数字前面填充'0'而不是默认的空格 |
| % | '%%'输出一个单一的'%' |
| (var) | 映射变量(字典参数) |
| m.n. |
format()
format()另外一种格式化字符串的format()方法， 它会用传入的参数一次替换字符串的占位符{0}，{1}，{2}...
>>> 'hello, {0}, 你的成绩是：{1:.3f}'.format('小明',98.33)
'hello, 小明, 你的成绩是：98.330'
3.2 输入
python可以使用input()函数 获取用户从键盘输入的内容。可以使用一个变量接收输入的内容。使用方法如下：
name = input("Please input your name:")
print("Name is: %s:" % name)
四、条件判断
if <条件判断1>:
<执行1>
elif <条件判断2>:
<执行2>
elif <条件判断3>:
<执行3>
else:
<执行4>
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 n = 3 5 while n > 0: 6 name = input("Please input Username:") 7 pass = input("please input Password:") 8 if name == "zkc" and pass == "123456": 9 print("Login Successful!") 10 break 11 else: 12 print("Username or Password Error!") 13 n = n - 1 14 print("你还有%d次机会" % n)
五、循环
python循环有 for 和 while语句
## while语句：要条件满足，就不断循环，条件不满足时退出循环。
while 条件语句:
## 遍历列表
for x in range(100):
for x in [1,2,3,4,5]:
break： 在循环中，break语句可以提前退出循环。
continue： 在循环过程中，也可以通过continue语句，跳过当前的这次循环，直接开始下一次循环。
六、Python基本数据类型
6.1运算符
6.1.1 算术运算符
以下假设变量： a=10，b=20：
| 运算符 | 描述 | 实例 |
|---|---|---|
| + | 加 - 两个对象相加 | a + b 输出结果 30 |
| - | 减 - 得到负数或是一个数减去另一个数 | a - b 输出结果 -10 |
| * | 乘 - 两个数相乘或是返回一个被重复若干次的字符串 | a * b 输出结果 200 |
| / | 除 - x除以y | b / a 输出结果 2 |
| % | 取模 - 返回除法的余数 | b % a 输出结果 0 |
| ** | 幂 - 返回x的y次幂 | a**b 为10的20次方， 输出结果 100000000000000000000 |
| // | 取整除 - 返回商的整数部分（向下取整） | >>> 9//2 4 >>> -9//2 -5 |
6.1.2 比较运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| == | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
| != | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
| <> | 不等于 - 比较两个对象是否不相等。python3 已废弃。 | (a <> b) 返回 true。这个运算符类似 != 。 |
| > | 大于 - 返回x是否大于y | (a > b) 返回 False。 |
| < | 小于 - 返回x是否小于y。所有比较运算符返回1表示真，返回0表示假。这分别与特殊的变量True和False等价。 | (a < b) 返回 true。 |
| >= | 大于等于 - 返回x是否大于等于y。 | (a >= b) 返回 False。 |
| <= | 小于等于 - 返回x是否小于等于y。 | (a <= b) 返回 true。 |
6.1.3 赋值运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符 | c = a + b 将 a + b 的运算结果赋值为 c |
| += | 加法赋值运算符 | c += a 等效于 c = c + a |
| -= | 减法赋值运算符 | c -= a 等效于 c = c - a |
| *= | 乘法赋值运算符 | c *= a 等效于 c = c * a |
| /= | 除法赋值运算符 | c /= a 等效于 c = c / a |
| %= | 取模赋值运算符 | c %= a 等效于 c = c % a |
| **= | 幂赋值运算符 | c = a 等效于 c = c a |
| //= | 取整除赋值运算符 | c //= a 等效于 c = c // a |
6.1. 4 位运算符
python的位运算是把数字看做二进制进行计算的。
a=60 b=13
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0 | (a & b) 输出结果 12 ，二进制解释： 0000 1100 |
| | | 按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。 | (a | b) 输出结果 61 ，二进制解释： 0011 1101 |
| ^ | 按位异或运算符：当两对应的二进位相异时，结果为1 | (a ^ b) 输出结果 49 ，二进制解释： 0011 0001 |
| ~ | 按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1 | (~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。 |
| << | 左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。 | a << 2 输出结果 240 ，二进制解释： 1111 0000 |
| >> | 右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数 | a >> 2 输出结果 15 ，二进制解释： 0000 1111 |
6.1.5 逻辑运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| and | 布尔与 如果x 为false，x and y 返回false，否则返回y的计算值。 | (a and b ) 返回true |
| or | 布尔或 如果x为True, x and y返回True, 否则返回y的计算值。 | (a and b ) 返回true |
| not | 布尔非 就是取反， 如果x为true，返回false. | not (a and b ) 返回false |
6.1.6 成员运算符
| 算符 | 描述 | 实例 |
|---|---|---|
| in | 如果指定的成员在序列中找到值，返回True 否则False | |
| not in | 如果指定的成员在序列中没有找到值，返回True 否则False |
6.1. 身份运算符
| 运算符 | 描述 | 实例 |
|---|---|---|
| is | is 是判断两个标识符是不是引用自一个对象 | x is y, 类似 id(x) == id(y) , 如果引用的是同一个对象则返回 True，否则返回 False |
| is not | is not 是判断两个标识符是不是引用自不同对象 | x is not y ， 类似 id(a) != id(b)。如果引用的不是同一个对象则返回结果 True，否则返回 False。 |
# [id()](https://www.runoob.com/python/python-func-id.html) 函数用于获取对象内存地址。
# is 与 == 区别：
is 用于判断两个变量引用对象是否为同一个(同一块内存空间)， == 用于判断引用变量的值是否相等。
6.1.7 运算符优先级
| 运算符 | 描述 |
|---|---|
| ** | 指数 (最高优先级) |
| ~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@) |
| * / % // | 乘，除，取模和取整除 |
| + - | 加法减法 |
| >> << | 右移，左移运算符 |
| & | 位 'AND' |
| ^ | | 位运算符 |
| <= < > >= | 比较运算符 |
| <> == != | 等于运算符 |
| = %= /= //= -= += *= **= | 赋值运算符 |
| is is not | 身份运算符 |
| in not in | 成员运算符 |
| not and or | 逻辑运算符 |
6.2 基本数据类型
6.2.1 数字
Python数字类型包括
1. 整数和浮点数
2. 复数
3. 固定精度的十进制数
4. 有理分数
5. 集合
6. 布尔类型
7. 无穷的整数精度
8. 各种数字内置函数和模块
数字类型支持算术运算，还支持一些常用的数学模块 （math、random）和内置数学函数（pow, abs, round, int, hex, bin, min, max等）
## math
>>> import math
>>> math.pi
3.141592653589793
>>> math.sqrt(88)
9.38083151964686
>>> math.sqrt(64)
8.0
## random
>>> import random
>>> random.random()
0.6014985194240732
>>> random.choice([1,2,3,4,5])
4
## pow()
>>> pow(2,4) ==> 2**4
16
## abs() 绝对值
>>> abs(-12.4)
12.4
## sum()
>>> sum((1,2,3,4))
10
>>> sum([1,2,3])
6
## min(),max()
>>> min(1,10,-4,3),max(3,10,-9,199)
(-4, 199)
## int() 类型转换 bin()
>>> s='123'
>>> int(s)
123
>>> int(s,10)
123
>>> int(s,16)
291
>>> int(s,8)
83
>>> bin(2)
'0b10'
整型数据类型支持的具体方法可以参考 class int(object) 如：
def bit_length(self): # real signature unknown; restored from __doc__
>>> num = 12
>>> num.bit_length() ## 12 的二进制为 1100 4位
4
6.2.2 布尔型
6.2.3 字符串
字符串或串(String)是由数字、字母、下划线组成的一串字符。
在python中字符串也是一种序列 --- 字符串是单个字符的字符串的序列。序列还包括：列表和元组
在python中的每个对象都可分为不可变性和可变性， 在核心数据中：字符串、数字、元组是不可变的。
1. 字符串序列的操作：
>>> s='python'
>>> s[1:]
'ython'
>>> len(s)
6
>>> s[1:]
'ython'
>>> s[0]
'p'
>>> s[:]
'python'
>>> s[-1]
'n'
2.字符串支持 + 号 合并
>>> s="python"
>>> s1="language"
>>> s+s1
'pythonlanguage'
>>> s + ' ' + s1
'python language'
3. 字符串的不可变性
>>> s="python"
>>> s[0] = 'P'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> s = 'P' + s[1:]
>>> s
'Python'
4. 字符串特定的方法：
字符串提供了一系列的方法，实现更负载的文本处理任务。可以使用dir(s) S为字符串变量，查看有哪些方法：
>>> s
'Python'
>>> dir(s)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
>>>
# s.capitalize() 首字母大写
# s.casefold() 字符串全部改为小写 功能和s.lower一样，但是casefold功能更全面。
# s.center(width, fillchar=' ') 设置字符串长度，空白处指定字符填充
>>> ss.center(30,"*")
'*****Ks fF sa2D$FsqsdfER******
# s.count('n') # 子字符串n 在字符创s出现多少次，
# s.endwith("") #以什么结尾 s.startwith() # 以什么开始
# s.expandtabs(n) 方法把字符串中的 tab 符号 \t 转为空格，tab 符号 \t 默认的空格数是 8，在第 0、8、16...等处给出制表符位置，如果当前位置到开始位置或上一个制表符位置的字符数不足 8 的倍数则以空格代替。
info = "name\tpasswd\tmail\nzkc\t12345\tkk@qq.com\nzkc\t12345\tkk@qq.com\nzkc\t12345\tkk@qq.com\nzkc\t12345\tkk@qq.com\n"
print(info)
v = info.expandtabs(20)
print(v)
输出结果：
name passwd mail
zkc 12345 kk@qq.com
zkc 12345 kk@qq.com
zkc 12345 kk@qq.com
zkc 12345 kk@qq.com
name passwd mail
zkc 12345 kk@qq.com
zkc 12345 kk@qq.com
zkc 12345 kk@qq.com
zkc 12345 kk@qq.com
# s.format() 格式化， 将一个字符串中的占位符替换为指定的值
>>> s1 = "{lan} is a computer language"
>>> s2 = s1.format(lan="Python")
>>> s2
'Python is a computer language'
# 字符串修改 s.replace(old, new, count=-1, /)
>>> s=s.replace('Py',"kkkk")
>>> s
'kkkkthon'
>>> str1 = "you is a good boy!"
>>> str1.replace('o','BBB',1)
'yBBBu is a good boy!'
>>> str1.find('o')
1
# s.find('') 方法返回在子字符串出现处的偏移， 未找到时返回1
# s.index("ss") 子字符串ss 在s字符串中首次出现的序列号。 没有返回错误。 一般使用find替换。
>>> ss
'Ks fF sa2D$FsqsdfER'
>>> ss.index('sa')
6
# s.isalnum() #如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
>>> s = "asJd78SE"
>>> s.isalnum()
True
>>> s1 = "K,sfa*fsa"
>>> s1.isalnum()
False
# s.isalpha() #如果 string 至少有一个字符并且所有字符都是字母则返回 True,否则返回 False.
# s.isdecimal() #如果 string 只包含十进制数字则返回 True 否则返回 False.
# s.isdigit() #如果 string 只包含数字则返回 True 否则返回 False.
# s.isidentifier() #如果字符串是有效标识符，则 isidentifier() 方法返回 True，否则返回 False。
# s.islower() #如果字符串中的所有字符都是小写，则返回 True.
# s.isnumeric() #如果字符串中的所有字符都是数，则返回 True。
>>> s = "二"
>>> s.isdigit()
False
>>> s.isnumeric()
True
# s.isprintable() #如果字符串中有可转化字符(/t /n 等) 则为false。
>>> s.isprintable()
True
>>> s1="sfa\tsafsa"
>>> s1
'sfa\tsafsa'
>>> s1.isprintable()
False
# s.isspsce() #如果字符串中的所有字符都是空白字符，则返回 True。 空字符串
# s.istitle() ## 字符串是否为标题（在一个字符串中，每个字符的首字母都是大写）
# s.title() ## 将字符串转为 标题字符串
>>> s1="Python is a computer language"
>>> s1.title()
'Python Is A Computer Language'
>>> s1.istitle()
False
>>> s=s1.title()
>>> s.istitle()
True
# s.issupper() # 如果字符串中的所有字符都是大写，则返回 True。
# 字符串方法join 可以将列表合成一个字符串，通过特定字符将列表合成一个字符串
>>> L = ["python","learn","language"]
>>> L
['python', 'learn', 'language']
>>> PP = ':'.join(L)
>>> PP
'python:learn:language'
# s.strip(chars=None) s.lstrip(chars=None) s.rstrip(chars=None) # 去除字符串左右空白符 \n \t 或指定的字符
>>> s
' asfa\t'
>>> s.strip()
'asfa'
>>> s.lstrip()
'asfa\t'
>>> s.rstrip()
' asfa'
>>>
# s.maketrans() ## 方法用于创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
m = str.maketrans("love","5211")
print(m) ##结果为：{108: 53, 111: 50, 118: 49, 101: 49}
ss = "losfawvDvesaovdsl"
new_ss = ss.translate(ss)
print(new_ss) ## 结果为：losfawvDvesaovdsl
# s.partition(str) ##有点像 find()和 split()的结合体,从 str 出现的第一个位置起,把字符串s分成一个3元素的元组 (string_pre_str,str,string_post_str),如果 s中不包含str 则 string_pre_str == s.
s = "sfsdfedgasffas"
v = s.partition('a')
print(v) ##结果为：('sfsdfedg', 'a', 'sffas')
# s.split('分隔符') split方法将一个字符串以分隔符分隔成一个列表，默认是分隔符为空格。
# s.swapcase() # s中大小写转换
字符串练习：
1. 环提示用户输入：用户名，密码，邮箱（要求用户输入的长度不超过20个字，如果超过则只有前20个字符有效）如果用户输入q或Q表示不再继续输入。
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 info="" 4 while True: 5 username = input("Input your name(less than 20byte):") 6 passwd = input("Input your password:") 7 mails = input("Input your mail:") 8 if len(username) > 20: 9 username = username[:20] 10 11 result = "Username\tPassword\tMail\n{0}\t{1}\t{2}\n" 12 result = result.format(username,passwd,mails) 13 info += result 14 print(info.expandtabs(25)) 15 res = input("Do you want to continue:(yes/q/Q)") 16 if res == 'q' or res == 'Q': 17 break
2.制作验证码验证， 登录次数限制；
1 def check_code(): 2 import random 3 checkcode = '' 4 for i in range(4): 5 current = random.randrange(0, 4) 6 if current != i: 7 temp = chr(random.randint(65, 90)) 8 else: 9 temp = random.randint(0, 9) 10 checkcode += str(temp) 11 return checkcode 12 13 sec = 3 14 while sec > 0: 15 name = input("请输入用户名: ") 16 Passwd = input("请输入密码: ") 17 if name != 'zkc' or Passwd != '123': 18 print("用户名或密码错误!") 19 sec -= 1 20 continue 21 code = check_code() 22 code = code.lower() 23 print("验证码为：%s" % code) 24 s = input("请输入验证码: ") 25 if s == code: 26 print("登录成功") 27 break 28 else: 29 print("验证码错误")
6.2.4 列表
# 列表是Python最具灵活性的有序集合对象类型。具有以下属性： 1. 任意对象的有序集合 2. 通过偏移读取数据内容 3. 可变长度， 异构以及任意嵌套 长度可增可短，可包含任意类型的对象（异构），列表中还可以嵌套列表 l = [1, 2, 3, 4, "sdfa", "sfa", [123, 5.4]] 4. 属于可变序列的分类 列表支持原处修改，如删除，修改和索引赋值等操作。 5. 对象应用数组 Python列表包含了零个或多个其他对象的引用， 在标准Python解释器内部，列表就是C数组而不是链接结构。 在用到引用时， Python总是会将这个引用指向一个对象，所以程序只需处理对象的操作。 当把一个对象赋值一个数据结构元素或变量名时，Python总是会存储对象的引用，而不是对象的一个拷贝。 # 可以使用help(list)或者dir(list)查看list方法的完整列表清单。
列表操作
#基本操作 1. 列表合并和重复 >>> l = ["python","language"] >>> l1 = ["java","c","c++"] >>> l + l1 ['python', 'language', 'java', 'c', 'c++'] >>> l * 2 ['python', 'language', 'python', 'language'] 2. 索引取值（切片） 索引取值和字符串的相同 >>> l[1] 'language' >>> l[:] ['python', 'language'] >>> l1[:3] ['java', 'c', 'c++'] # 修改列表的值 >>> l1[1]="go" >>> l1 ['java', 'go', 'c++'] #列表迭代和解析 1. 成员关系 >>> "python" in l True 2. 迭代，遍历 >>> for i in l1: ... print(i) ... java c c++ >>> l2 = [i for i in "Linux system"] >>> l2 ['L', 'i', 'n', 'u', 'x', ' ', 's', 'y', 's', 't', 'e', 'm'] >>> l3 = [k**2 for k in range(5) ] >>> l3 [0, 1, 4, 9, 16] >>> list(map(abs,[-1,-19,932,88,23,87,-293])) [1, 19, 932, 88, 23, 87, 293] #列表方法的调用 1. list.append() 在列表中追加对象 >>> l1 ['java', 'go', 'c++'] >>> l1.append("Python") >>> l1 ['java', 'go', 'c++', 'Python'] 2. 对列表进行排序 排序方法有两种，一个是list.sort() 另外一个就是 sorted() 1. list.sort(key=None,reverse=False) #将list自身进行排序,不返回新的list对象,默认升序; 2. sorted(iterable,key=None,reverse=False) #返回排好序的新列表,不改变对象本身,默认升序. ## list.sort() >>> l1.sort() >>> l1 ['Python', 'c++', 'go', 'java'] >>> l1 ['Python', 'c++', 'go', 'java'] >>> l1.sort(key=str.lower) >>> l1 ['c++', 'go', 'java', 'Python'] ## sorted() >>> L ['abc', 'MND', 'saFS', 'def'] >>> sorted(L) ['MND', 'abc', 'def', 'saFS'] >>> sorted(L,reverse=True) ['saFS', 'def', 'abc', 'MND'] >>> sorted(L, key=str.lower, reverse=True) ['saFS', 'MND', 'def', 'abc'] >> L ['abc', 'MND', 'saFS', 'def'] >>> sorted([x.lower() for x in L], reverse=True) ['safs', 'mnd', 'def', 'abc'] 3. list.extend() 方法能够在列表末端插入多个元素 extend(self, iterable, /) ## 可迭代对象 >>> l1.extend(["C#","shell","c"]) >>> l1 ['c++', 'go', 'java', 'Python', 'C#', 'shell', 'c'] 4. list.insert() 方法 指定位置插入元素 insert(self, index, object, /) >>> l1 ['c++', 'java', 'Python', 'C#', 'shell'] >>> >>> l1.insert(1, "Java") >>> l1 ['c++', 'Java', 'java', 'Python', 'C#', 'shell'] 5. list.pop() 方法可以删除列表指定位置的元素（默认为末端） pop(self, index=-1, /) >>> l1 ['c++', 'go', 'java', 'Python', 'C#', 'shell', 'c'] >>> l1.pop(1) 'go' >>> l1 ['c++', 'java', 'Python', 'C#', 'shell', 'c'] >>> l1.pop() 'c' >>> l1 ['c++', 'java', 'Python', 'C#', 'shell'] 6. del删除某项或某片段 >>> del(l1[0]) >>> l1 ['Java', 'java', 'Python', 'C#', 'shell'] >>> del(l1[:3]) >>> l1 ['C#', 'shell'] 7. list.remove() ## 删除列表某个元素 remove(self, value, /) 8. list.copy() ##浅拷贝 >>> l2 = l1.copy() >>> l1 ['C#', 'shell'] >>> l2 ['C#', 'shell'] >>> id(l1) 2648704676360 >>> id(l2) 2648702454472 9. list.reverse() ## 将列表进行翻转
6.2.5 元组
元组：tuple 元组有简单的对象组构成，元组不能在原处修改， 是一个不可变的python类型。 元组使用圆括号() ， 具有以下属性： 1. 任意对象的有序集合 元组是一个有序的对象的集合， 与列表相同， 可以嵌套到任何类别的对象中。 2. 通过偏移存取 同字符串、列表一样，在元组中的元素通过偏移来访问。如索引和分片 3. 属于不可变序列类型 和字符串一样，元组也是不可变类型。不支持在原处进行修改操作。 4. 固定长度，异构，任意嵌套 因为元组是不可变的，所以在不生成一个拷贝的情况下，不能进行增长和缩短。元组可以包含其他的复合对象。 5. 对象引用的数组
常见元组常量和运算
() #空元组 T=(0,'KK',1.2,3,) # 四个元素的元组 T=("jelp",("hello","sk")) # 嵌套元组 T = tuple('python') # 一个可迭代对象的项的元组 T[i] T[i][j] len(T) T1 + T2 # 合并 T1 * 2 # 重复 for x in T: print(x) # 迭代 'jelp' in T1 [x**2 for x in T1]# 成员关系 #元组中方法 tuple.count() count(self, value, /) tuple.index() index(self, value, start=0, stop=9223372036854775807, /) # 字符串，元组，列表之间的相互转换 >>> s = "python" >>> tu = tuple(s) >>> tu ('p', 'y', 't', 'h', 'o', 'n') >>> t1 = ("python","ni","la") >>> s1 = ''.join(t1) #当t1中的元素全部为字符串 >>> s1 'pythonnila' >>> list(tu) ['p', 'y', 't', 'h', 'o', 'n'] >>> L1 = [1,2,3,4] >>> tuple(L1) (1, 2, 3, 4)
6.2.6 字典
字典-dict 是python中最灵活的内置数据结构类型。 相比列表是有序的对象集合，那字典就是无序的集合。主要差别是在： 字典的元素是通过键来存取的，而不是通过偏移存取。 具有以下属性： 1. 通过键而不是偏移来存取数据 2. 任意对象的无序集合 3. 可变长，异构，任意嵌套 4. 属于可变映射类型 -- 键值映射 5. 对象引用表（散列表） 字典作为散列表（支持快速检索的数据结构）来实现的，字典存储的是对象引用（而不是拷贝） # 可以使用help(dict)或者dir(dict)查看dict方法的完整列表清单。 ## 元组可以作为字典的key
# 字典常量和操作 D = {} #空字典 D = {"name":"python","age":25} # 两项目字典 D = {"language":{"gaoji":"GO", "other": "java"}} #嵌套 D = dict.fromkeys(['a','b']) ## 其他方法进行构建 dict D = dict(name="zkc",age=26) D["name"] ## 以键进行索引 其值 "name" in D ## 成员关系， 键存在与否 D.keys() ## 获取D中键 返回可迭代的视图，可通过for遍历此值 >>> D.keys() dict_keys(['name', 'age']) >>> for i in D.keys(): ... print(i) ... name age D.values() ## 获取D中值，返回可迭代的视图，可通过for遍历此值 D.items() ## 获取键和值，返回可迭代的视图，可通过for遍历此值 >>> D.items() dict_items([('name', 'zkc'), ('age', 26)]) >>> for k,v in D.items(): ... print(k, v) ... name zkc age 26 D.copy() #拷贝 副本 >>> d1 = D.copy() >>> d1 {'name': 'zkc', 'age': 26} >>> id(d1) 2648704711920 >>> id(D) 2648704712208 D.get(key,defalut) # 根据键获取值 D.update(D2) ## 合并 D.pop(key) ## 删除 len(D) ## 获取字典长度 D[key] = "python" # 新增，修改，删除键 del D[key] ## 根据键删除条目 list(D.keys()) D = {x:x**2 for x in range(8)} ##字典解析 dict.setdefault() # 设置值，已经存在获取当前值， 不存在添加给定的默认值
示例：
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 ### 9*9乘法表 5 # for i in range(1, 10): 6 # for j in range(1, i + 1): 7 # print("%d * %d = %d\t" % (j, i, i * j), end="") 8 # print("") 9 10 user_info = [] 11 for i in range(321): 12 user_info.append({"name": "ccx" + str(i), "mail": "ccx" + str(i) + "@ccx.cn", "address": i}) 13 14 # 输出所以user info 内容： 15 # for i in range(303): 16 # for k, v in user_info[i].items(): 17 # print("%s\t" % str(v), end="") 18 # print("") 19 # 每页十条数据 20 # user_info[0:10] ##第一页 21 # user_info[10:20] ##第二页 22 # user_info[20:30] ##第三页 23 # 所以第 5 页 的内容就在 user_info[4*10,5*10] 24 25 # 总页数 26 total_page = len(user_info) // 10 + 1 27 # 最后一页的条数： 28 other_info = len(user_info) % 10 29 30 while True: 31 page = input("请输入页数：") 32 if not page.isnumeric(): 33 print("请输入数字!!\t",end="") 34 continue 35 page = int(page) 36 if page > total_page: 37 print("超出页数！") 38 continue 39 #当时最后一页时， 内容取值范围 40 if page == total_page: 41 start_info = (page - 1) * 10 42 end_info = start_info + other_info 43 else: 44 start_info = (page-1) * 10 45 end_info = page * 10 46 47 title_info = "name\tmail\taddress" 48 print(title_info.expandtabs(20)) 49 50 for i in range(start_info, end_info): 51 for v in user_info[i].values(): 52 print("%s\t" % str(v), end="\t\t") 53 print("")
6.2.7集合
集合（set） 是唯一、不可变的对象的一个无序集合。集合有着广泛的引用，尤其是在涉及数字和数据库的工作中。 python3中可以使用 {} 和set()函数创建集合， 创建一个空集合必须使用set() 函数 # 集合的定义： parame = {value01,value02,...} 或者 set(value) >>> s {1, 2, 3, 4, 5} >>> type(s) <class 'set'> # 集合间的运算 >>> s1 = {1,2,3,4,5} >>> s2 = {3,49,2,10} >>> 3 in s1 # 判断元素是否存在集合内 True # 差集 difference >>> s1 -s2 # 集合s1包含而集合s2 中不包含的元素,和集合的内置函数difference一样：s1.difference(s2) {1, 4, 5} >>> s1.difference(s2) {1, 4, 5} #其中函数：difference_update() 是将结果返回给调用此函数的集合。如 >>> S1.difference(S2) {1, 2} >>> S1 {1, 2, 3, 4} >>> S1.difference_update(S2) >>> S1 {1, 2} # 并集 union >>> s1 | s2 # 集合s1和集合s2的并集Union, 和集合的内置函数 union() 一样：s1.union(s2) {1, 2, 3, 4, 5, 10, 49} >>> s1.union(s2) {1, 2, 3, 4, 5, 10, 49} # 交集 >>> s1 & s2 # 集合s1 和集合s2 的交集intersection，和集合的内置函数intersection() 一样: s1.intersection(s2) {2, 3} >>> s1.intersection(s2) {2, 3} # symmetric_difference() 返回两个集合中不重复的元素集合。 交叉补集 >>> s1 ^ s2 # 不同时包含于s1 和 s2 的元素 {1, 4, 5, 10, 49} >>> s1.symmetric_difference(s2) {1, 4, 5, 10, 49} # 子集判断 issubset() >>> s1 {1, 2, 4} >>> s2 {1, 2, 3, 4, 5} >>> s1.issubset(s2) True #其中使用 s2.issuperset(s1)的结果上上述一样： 父集判断 >>> s2.issuperset(s1) True # set.isdisjoint() # 两个集合的交集为空则返回true >>> S1 = {1,2,3,4} >>> S2 = {5,6,7,8} >>> S1.isdisjoint(S2) True >>> S1 & S2 set()
集合的基本操作
1. 添加元素 set.add(x) set.update(x) # 参数可以是列表， 元组， 字典等 >>> s2.add("Python") >>> print(s2) {2, 3, 'Python', 'Language', 10, 49} >>> s2.update(("c++","Go",)) >>> s2 {2, 3, 'Python', 'Language', 10, 49, 'c++', 'Go'} >>> s2.update({"name":"zkc"}) >>> s2 {2, 3, 'Python', 'Language', 10, 49, 'c++', 'Go', 'name'} >>> s2.update(["java","Ops"]) >>> s2 {2, 3, 'Python', 'Language', 10, 'Ops', 'java', 49, 'c++', 'Go', 'name'} 2. 移除元素 set.remove(X) set.discard(x) set.pop() #随机删除集合中的元素 3. 清空集合 set.clear() 4. 集合解析 >>> {x**2 for x in [1,2,3,4,5]} {1, 4, 9, 16, 25} 5. 集合列表的相互转换 >>> s2 {1, 2, 3, 4, 5} >>> L2 = list(s2) >>> L2 [1, 2, 3, 4, 5] >>> L3 = ["zkc", "ks", "yj"] >>> L3 ['zkc', 'ks', 'yj'] >>> S3 = set(L3) >>> S3 {'ks', 'zkc', 'yj'}
示例
1 #!/usr/bin/env python 2 # -*- coding:utf-8 -*- 3 4 shop_car = [] 5 goods = [ 6 {"name": "电脑", "price": 6786}, 7 {"name": "鼠标", "price": 60}, 8 {"name": "Go语言基础", "price": 78}, 9 {"name": "Jenkins 2权威指南", "price": 128}, 10 ] 11 s = "index\tgoods\tprice" 12 s = s.expandtabs(10) 13 print(s) 14 for i in enumerate(goods): 15 inde = i[0] 16 goods_name = i[1]["name"] 17 goods_price = i[1]["price"] 18 s1 = "%-6d\t%-6s\t%-6s" % (inde, goods_name, goods_price) 19 # s1 = "%(index)d\t%(name)s\t%(price)s" % {"index": inde, "name": goods_name, "price": goods_price} 20 s1.expandtabs(20) 21 print(s1) 22 23 money = input("Please input money: ") 24 money = int(money) 25 26 27 def display_shopcar(l): 28 print("购物车物品如下: ") 29 for i in enumerate(l): 30 print("%d\t%s\t价格:%d" % (i[0], i[1][0], i[1][1])) 31 32 33 while True: 34 goods_index = input("请输入购买物品序号: ").strip() 35 if goods_index.isdigit(): 36 goods_index = int(goods_index) 37 if goods_index < len(goods) and goods_index >= 0: 38 gname = goods[goods_index]["name"] 39 gprice = goods[goods_index]["price"] 40 print("此物已添加购物车") 41 shop_car.append((gname, gprice,)) 42 choice = input("是否继续添加物品（y/n）") 43 choice = choice.lower() 44 if choice == "n": 45 break 46 else: 47 print("输入错误！") 48 49 50 def chongzhi(): 51 global money 52 while True: 53 amoney = input("请输入充值数: ") 54 if amoney.isdigit(): 55 amoney = int(amoney) 56 money += amoney 57 print("当前余额为: %d" % money) 58 break 59 else: 60 print("输入错误") 61 continue 62 63 64 def jiezhang(): 65 global money 66 total_price = 0 67 buy_goods = [] 68 display_shopcar(shop_car) 69 nums = input("请输入需结账物品的序号: ") 70 for n in nums: 71 n = int(n) 72 print(n) 73 print(shop_car) 74 print(shop_car[n]) 75 buy_goods.append(shop_car[n]) 76 77 78 for i in buy_goods: 79 total_price += i[1] 80 if total_price > money: 81 print("余额不足！ 相差: %d元" % (total_price - money)) 82 choice = input("是否进行充值（y/n）").strip().lower() 83 if choice == "y": 84 chongzhi() 85 else: 86 print("余额不足，退出购买！") 87 if money >= total_price: 88 money -= total_price 89 print("成功购买!") 90 print("当前余额为: %d" % money) 91 display_shopcar(shop_car) 92 else: 93 print("余额不足，退出购买！") 94 95 if __name__ == "__main__": 96 jiezhang()
浙公网安备 33010602011771号