Day02 Python 基本数据类型
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Day02 Python 基本数据类型相关的知识,希望对你有一定的参考价值。
1 基本数据类型
Python有五个标准的数据类型:
- Numbers(数字)
- String(字符串)
- List(列表)
- Tuple(元组)
- Dictionary(字典)
1.1 数字
数字数据类型用于存储数值,是不可改变的数据类型,这意味着改变数字数据类型会分配一个新的对象。
Python支持四种不同的数字类型:
- int(有符号整型)
- long(长整型[也可以代表八进制和十六进制])
- float(浮点型)
- complex(复数)
- bool(True和False,1和0)
当你指定一个值时,Number对象就会被创建:
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 number_a = 18 #整数 int 5 number_b = 3.1 #浮点 float 6 number_c = True #布尔 bool 7 number_d = 7+3j #复数 complex 8 print(type(number_a),"\n", type(number_b), "\n",type(number_c), "\n",type(number_d))
输出结果:
1 <class ‘int‘> 2 <class ‘float‘> 3 <class ‘bool‘> 4 <class ‘complex‘>
- 长整型也可以使用小写"L",但是还是建议您使用大写"L",避免与数字"1"混淆。Python使用"L"来显示长整型。
- Python还支持复数,复数由实数部分和虚数部分构成,可以用a + bj,或者complex(a,b)表示, 复数的实部a和虚部b都是浮点型
数值运算
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 #数值运算 5 print (13+17) #加法 6 print (888-666) #减法 7 print (37 * 47) #乘法 8 print (3/4) #除法,得到一个浮点数 9 print (3//4) #整除,得到一个整数 10 print (22%3) #取余 11 print (3**2) #乘方
输出结果:
1 30 2 222 3 1739 4 0.75 5 0 6 1 7 9
注意:
- Python可以同时为多个变量赋值,如x, y = 1, 2。
- 数字运算的优先级是先乘除后加减,可以通过()来改变运算顺序。例如 print ((2+3)*3)。
- 数值的除法(/)总是返回一个浮点数,要获取整数使用//操作符。
- 在混合计算时,Python会把整型转换成为浮点数。
1.2 字符串
- 移除空白
- 分割
- 长度
- 索引
- 切片
capitalize(self)
首字母变大写
1 >>> "hello world".capitalize() 2 ‘Hello world‘
center(self, width, fillchar=None)
内容居中
width:总长度
fillchar:空白处填充内容,默认无
1 >>> "hello world".center(20,"*") 2 ‘****hello world*****‘
count(self, sub, start=None, end=None)
子序列的个数
1 >>> "hello world".count("l") 2 3
startswith(self, prefix, start=None, end=None)
是否以XXX起始
1 >>> "hello world".startswith("h") 2 True
endswith(self, suffix, start=None, end=None)
判断字符串是否以XXX字符结束
1 >>> "hello world".endswith("d") 2 True
expandtabs(self, tabsize=None)
将tab转换成空格,默认一个tab转换成8个空格
1 >>> "hello\tworld".expandtabs() 2 ‘hello world‘
find(self, sub, start=None, end=None)
寻找子序列的位置,如果没找到,返回 -1
1 >>> "hello world".find("o") 2 4
format(*args, **kwargs)
字符串格式化,动态参数
1 >>> "{} {}".format("James","24") 2 ‘James 24‘ 3 >>> "{1} {0} {1}".format("James","24") 4 ‘24 James 24‘
index(self, sub, start=None, end=None)
子序列位置,如果没找到,报错
1 >>> "hello world".index("w") 2 6
isalnum(self)
是否是字母和数字
1 >>> "hello3".isalnum() 2 True 3 >>> "hello world".isalnum() 4 False 5 >>> "123".isalnum() 6 True 7 >>> "hello".isalnum() 8 True
isalpha(self)
是否是字母
1 >>> "hello".isalnum() 2 True 3 >>> "123".isalnum() 4 True
isdigit(self)
是否是数字
1 >>> "123".isdigit() 2 True 3 >>> "hello".isdigit() 4 False 5 >>> "hello123".isdigit() 6 False
islower(self)
是否小写
1 >>> "hello".islower() 2 True 3 >>> "Hello".islower() 4 False
isupper(self)
是否大写
1 >>> "hello".isupper() 2 False 3 >>> "Hello".isupper() 4 False 5 >>> "HELLO".isupper() 6 True
lower(self)
变小写
1 >>> ‘HELLO‘.lower() 2 ‘hello‘
upper(self)
变大写
1 >>> "hello".upper() 2 ‘HELLO‘
swapcase(self)
大写变小写,小写变大写
1 >>> "Hello World".swapcase() 2 ‘hELLO wORLD‘
ljust(self, width, fillchar=None)
内容左对齐,右侧填充
1 >>> "hello world".ljust(20,"*") 2 ‘hello world*********‘
rjust(self, width, fillchar=None)
内容右对齐,左侧填充
1 >>> "hello world".rjust(20,"*") 2 ‘*********hello world‘
strip(self, chars=None)
移除两端空白
1 >>> " hello world ".strip() 2 ‘hello world‘
lstrip(self, chars=None)
移除左侧空白
1 >>> " hello world ".lstrip() 2 ‘hello world ‘
rstrip(self, chars=None)
移除右侧空白
1 >>> " hello world ".rstrip() 2 ‘ hello world‘
replace(self, old, new, count=None)
替换
1 >>> "hello world".replace("o","*") 2 ‘hell* w*rld‘
1.3 列表
List(列表)是Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。它支持字符,数字,字符串甚至可以包含列表(所谓嵌套)。
列表用[ ]标识。是python最通用的复合数据类型。
创建列表:
name_list
=
[
‘James‘
,
‘Kobe‘
,
‘Yao‘
]
或者
name_list =
list
([
‘James‘
,
‘Koe‘
,
‘Yao‘
])
列表中的值的分割也可以用到变量[头下标:尾下标],就可以截取相应的列表,从左到右索引默认0开始的,从右到左索引默认-1开始,下标可以为空表示取到头或尾。
加号(+)是列表连接运算符,星号(*)是重复操作。
如下实例:
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 list = [ ‘James‘, 786 , 2.23, ‘john‘, 70.2 ] 5 tinylist = [123, ‘john‘] 6 7 print(list) # 输出完整列表 8 print(list[0]) # 输出列表的第一个元素 9 print(list[1:3]) # 输出第二个至第三个的元素 10 print(list[2:]) # 输出从第三个开始至列表末尾的所有元素 11 print(tinylist * 2) # 输出列表两次 12 print(list + tinylist) # 打印组合的列表
输出结果:
1 [‘James‘, 786, 2.23, ‘john‘, 70.2] 2 James 3 [786, 2.23] 4 [2.23, ‘john‘, 70.2] 5 [123, ‘john‘, 123, ‘john‘] 6 [‘James‘, 786, 2.23, ‘john‘, 70.2, 123, ‘john‘]
append(self, p_object)
1 >>> name = ["James","Kobe","Yao"] 2 >>> name.append("Rose") 3 >>> print(name) 4 [‘James‘, ‘Kobe‘, ‘Yao‘, ‘Rose‘]
count(self, value)
1 >>> name = ["James","Kobe","Yao","James"] 2 >>> name.count("James") 3 2
extend(self, iterable)
1 >>> name1 = ["Kobe","James","Yao"] 2 >>> name2 = ["Ronaldo","Henry"] 3 >>> name1.extend(name2) 4 >>> print(name1) 5 [‘Kobe‘, ‘James‘, ‘Yao‘, ‘Ronaldo‘, ‘Henry‘]
index(self, value, start=None, stop=None)
1 >>> name = ["James","Kobe","Yao","James"] 2 >>> name.index("Yao") 3 2
insert(self, index, p_object)
1 >>> name = ["James","Kobe","Yao","James"] 2 >>> name.insert(2,"Henry") 3 >>> print(name) 4 [‘James‘, ‘Kobe‘, ‘Henry‘, ‘Yao‘, ‘James‘]
pop(self, index=None)
1 >>> name = ["James","Kobe","Yao","James"] 2 >>> name.pop() 3 ‘James‘ 4 >>> print(name) 5 [‘James‘, ‘Kobe‘, ‘Yao‘]
remove(self, value)
1 >>> name = ["James","Kobe","Yao","James"] 2 >>> name.remove("James") 3 >>> print(name) 4 [‘Kobe‘, ‘Yao‘, ‘James‘]
reverse(self)
1 >>> name = ["James","Kobe","Yao"] 2 >>> name.reverse() 3 >>> print(name) 4 [‘Yao‘, ‘Kobe‘, ‘James‘]
sort(self, cmp=None, key=None, reverse=False)
1 >>> name = ["Ronaldo","Kobe","James","Yao","123"] 2 >>> name.sort() 3 >>> print(name) 4 [‘123‘, ‘James‘, ‘Kobe‘, ‘Ronaldo‘, ‘Yao‘]
1.4 元组
元组是另一个数据类型,类似于List(列表)。
元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值,相当于只读列表。
- 索引
- 切片
- 循环
- 长度
- 包含
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 tuple = ( ‘James‘, 786 , 2.23, ‘john‘, 70.2 ) 5 tinytuple = (123, ‘john‘) 6 7 print(tuple) # 输出完整元组 8 print(tuple[0]) # 输出元组的第一个元素 9 print(tuple[1:3]) # 输出第二个至第三个的元素 10 print(tuple[2:]) # 输出从第三个开始至列表末尾的所有元素 11 print(tinytuple * 2) # 输出元组两次 12 print(tuple + tinytuple) # 打印组合的元组
输出结果:
1 (‘James‘, 786, 2.23, ‘john‘, 70.2) 2 James 3 (786, 2.23) 4 (2.23, ‘john‘, 70.2) 5 (123, ‘john‘, 123, ‘john‘) 6 (‘James‘, 786, 2.23, ‘john‘, 70.2, 123, ‘john‘)
count(self, value)
1 >>> name = ("James","Kobe","James","Yao","James") 2 >>> name.count("James") 3 3
index(self, value, start=None, stop=None)
1 >>> name = ("James","Kobe","James","Yao","James") 2 >>> name.index("James") 3 0 4 >>> name.index("Yao") 5 3
1.5 字典
字典(dictionary)是除列表以外python之中最灵活的内置数据结构类型。列表是有序的对象结合,字典是无序的对象集合。
两者之间的区别在于:字典当中的元素是通过键来存取的,而不是通过偏移存取。
字典用"{ }"标识。字典由索引(key)和它对应的值value组成。
常用操作:
- 索引
- 新增
- 删除
- 键、值、键值对
- 循环
- 长度
如下实例:
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 dict = {} 5 dict[‘one‘] = "This is one" 6 dict[2] = "This is two" 7 8 tinydict = {‘name‘: ‘john‘,‘code‘:6734, ‘dept‘: ‘sales‘} 9 10 11 print(dict[‘one‘]) # 输出键为‘one‘ 的值 12 print(dict[2]) # 输出键为 2 的值 13 print(tinydict) # 输出完整的字典 14 print(tinydict.keys()) # 输出所有键 15 print(tinydict.values()) # 输出所有值
输出结果:
1 This is one 2 This is two 3 {‘code‘: 6734, ‘name‘: ‘john‘, ‘dept‘: ‘sales‘} 4 dict_keys([‘code‘, ‘name‘, ‘dept‘]) 5 dict_values([6734, ‘john‘, ‘sales‘])
clear(self)
清除内容
1 >>> person = {"name":"James","age":24} 2 >>> person.clear() 3 >>> print(person) 4 {}
copy(self)
浅拷贝
1 >>> person1 = {"name":"James","age":24} 2 >>> person2 = person1.copy() 3 >>> print(person2) 4 {‘name‘: ‘James‘, ‘age‘: 24} 5 >>> id(person1) 6 3082800364 7 >>> id(person2) 8 3082798892
get(self, k, d=None)
根据key获取值,d是默认值
1 >>> person = {"name":"James","age":24} 2 >>> person.get("name") 3 ‘James‘
items(self)
所有项的列表形式
1 >>> person = {"name":"James","age":24} 2 >>> person.items() 3 dict_items([(‘name‘, ‘James‘), (‘age‘, 24)])
keys(self)
所有的key列表
1 >>> person = {"name":"James","age":24} 2 >>> person.keys() 3 dict_keys([‘name‘, ‘age‘])
pop(self, k, d=None)
获取并在字典中移除
1 >>> person = {"name":"James","age":24} 2 >>> person.pop("name") 3 ‘James‘ 4 >>> print(person) 5 {‘age‘: 24}
popitem(self)
获取并在字典中移除
1 >>> person = {"name":"James","age":24} 2 >>> person.popitem() 3 (‘name‘, ‘James‘) 4 >>> print(person) 5 {‘age‘: 24}
setdefault(self, k, d=None)
如果key不存在,则创建,如果存在,则返回已存在的值且不修改
1 >>> person = {"name":"James","age":24} 2 >>> person.setdefault("name") 3 ‘James‘ 4 >>> person.setdefault("sex") 5 >>> print(person) 6 {‘name‘: ‘James‘, ‘age‘: 24, ‘sex‘: None}
update(self, E=None, **F)
更新
1 >>> person1 = {"name":"James","age":24} 2 >>> person2 = {"tel":"10086"} 3 >>> person1.update(person2) 4 >>> print(person1) 5 {‘name‘: ‘James‘, ‘age‘: 24, ‘tel‘: ‘10086‘}
values(self)
所有的值
1 >>> person = {"name":"James","age":24} 2 >>> person.values() 3 dict_values([‘James‘, 24])
2 其他
2.1 运算符
- 三元运算符(三目运算符)
result = 值1 if 条件 else 值2 #如果条件成立,那么讲“值1”赋值给result变量,否则将“值2”赋值给result变量。
如下实例:
1 >>> result = "James" if 2<3 else "Kobe" 2 >>> print(result) 3 James 4 >>> result = "James" if 2>3 else "Kobe" 5 >>> print(result) 6 Kobe
- 算术运算符
运算符 | 描述 | 实例 |
---|---|---|
+ | 加 - 两个对象相加 | 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.0//2.0 输出结果 4.0 |
如下实例:
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 a = 21 5 b = 10 6 c = 0 7 8 c = a + b 9 print("1 - c 的值为:", c) 10 11 c = a - b 12 print("2 - c 的值为:", c) 13 14 c = a * b 15 print("3 - c 的值为:", c) 16 17 c = a / b 18 print("4 - c 的值为:", c) 19 20 c = a % b 21 print("5 - c 的值为:", c) 22 23 # 修改变量 a 、b 、c 24 a = 2 25 b = 3 26 c = a**b 27 print("6 - c 的值为:", c) 28 29 a = 10 30 b = 5 31 c = a//b 32 print("7 - c 的值为:", c)
输出结果:
1 1 - c 的值为: 31 2 2 - c 的值为: 11 3 3 - c 的值为: 210 4 4 - c 的值为: 2.1 5 5 - c 的值为: 1 6 6 - c 的值为: 8 7 7 - c 的值为: 2
- 比较运算符
运算符 | 描述 | 实例 |
---|---|---|
== | 等于 - 比较对象是否相等 | (a == b) 返回 False。 |
!= | 不等于 - 比较两个对象是否不相等 | (a != b) 返回 true. |
<> | 不等于 - 比较两个对象是否不相等 | (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。 |
如下实例:
1 # -*- coding:UTF-8 -*- 2 3 a = 21 4 b = 10 5 c = 0 6 7 if ( a == b ): 8 print("1 - a 等于 b") 9 else: 10 print("1 - a 不等于 b") 11 12 if ( a != b ): 13 print("2 - a 不等于 b") 14 else: 15 print("2 - a 等于 b") 16 17 if ( a != b ): 18 print("3 - a 不等于 b") 19 else: 20 print("3 - a 等于 b") 21 22 if ( a < b ): 23 print("4 - a 小于 b") 24 else: 25 print("4 - a 大于等于 b") 26 27 if ( a > b ): 28 print("5 - a 大于 b") 29 else: 30 print("5 - a 小于等于 b") 31 32 # 修改变量 a 和 b 的值 33 a = 5; 34 b = 20; 35 if ( a <= b ): 36 print("6 - a 小于等于 b") 37 else: 38 print("6 - a 大于 b") 39 40 if ( b >= a ): 41 print("7 - b 大于等于 b") 42 else: 43 print("7 - b 小于 b")
输出结果:
1 1 - a 不等于 b 2 2 - a 不等于 b 3 3 - a 不等于 b 4 4 - a 大于等于 b 5 5 - a 大于 b 6 6 - a 小于等于 b 7 7 - b 大于等于 b
- 赋值运算符
运算符 | 描述 | 实例 |
---|---|---|
= | 简单的赋值运算符 | 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 |
如下实例:
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 a = 21 5 b = 10 6 c = 0 7 8 c = a + b 9 print("1 - c 的值为:", c) 10 11 c += a 12 print("2 - c 的值为:", c) 13 14 c *= a 15 print("3 - c 的值为:", c) 16 17 c /= a 18 print("4 - c 的值为:", c) 19 20 c = 2 21 c %= a 22 print("5 - c 的值为:", c) 23 24 c **= a 25 print("6 - c 的值为:", c) 26 27 c //= a 28 print("7 - c 的值为:", c)
输出结果:
1 1 - c 的值为: 31 2 2 - c 的值为: 52 3 3 - c 的值为: 1092 4 4 - c 的值为: 52.0 5 5 - c 的值为: 2 6 6 - c 的值为: 2097152 7 7 - c 的值为: 99864
- 位运算符
运算符 | 描述 | 实例 |
---|---|---|
& | 按位与运算符:参与运算的两个值,如果两个相应位都为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 | (~a ) 输出结果 -61 ,二进制解释: 1100 0011, 在一个有符号二进制数的补码形式。 |
<< | 左移动运算符:运算数的各二进位全部左移若干位,由"<<"右边的数指定移动的位数,高位丢弃,低位补0。 | a << 2 输出结果 240 ,二进制解释: 1111 0000 |
>> | 右移动运算符:把">>"左边的运算数的各二进位全部右移若干位,">>"右边的数指定移动的位数 | a >> 2 输出结果 15 ,二进制解释: 0000 1111 |
如下实例:
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 a = 60 # 60 = 0011 1100 5 b = 13 # 13 = 0000 1101 6 c = 0 7 8 c = a & b; # 12 = 0000 1100 9 print("1 - c 的值为:", c) 10 11 c = a | b; # 61 = 0011 1101 12 print("2 - c 的值为:", c) 13 14 c = a ^ b; # 49 = 0011 0001 15 print("3 - c 的值为:", c) 16 17 c = ~a; # -61 = 1100 0011 18 print("4 - c 的值为:", c) 19 20 c = a << 2; # 240 = 1111 0000 21 print("5 - c 的值为:", c) 22 23 c = a >> 2; # 15 = 0000 1111 24 print("6 - c 的值为:", c)
输出结果:
1 1 - c 的值为: 12 2 2 - c 的值为: 61 3 3 - c 的值为: 49 4 4 - c 的值为: -61 5 5 - c 的值为: 240 6 6 - c 的值为: 15
- 逻辑运算符
运算符 | 逻辑表达式 | 描述 | 实例 |
---|---|---|---|
and | x and y | 布尔"与" - 如果 x 为 False,x and y 返回 False,否则它返回 y 的计算值。 | (a and b) 返回 20。 |
or | x or y | 布尔"或" - 如果 x 是非 0,它返回 x 的值,否则它返回 y 的计算值。 | (a or b) 返回 10。 |
not | not x | 布尔"非" - 如果 x 为 True,返回 False 。如果 x 为 False,它返回 True。 | not(a and b) 返回 False |
如下实例:
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 a = 10 5 b = 20 6 7 if ( a and b ): 8 print("1 - 变量 a 和 b 都为 true") 9 else: 10 print("1 - 变量 a 和 b 有一个不为 true") 11 12 if ( a or b ): 13 print("2 - 变量 a 和 b 都为 true,或其中一个变量为 true") 14 else: 15 print("2 - 变量 a 和 b 都不为 true") 16 17 # 修改变量 a 的值 18 a = 0 19 if ( a and b ): 20 print("3 - 变量 a 和 b 都为 true") 21 else: 22 print("3 - 变量 a 和 b 有一个不为 true") 23 24 if ( a or b ): 25 print("4 - 变量 a 和 b 都为 true,或其中一个变量为 true") 26 else: 27 print("4 - 变量 a 和 b 都不为 true") 28 29 if not( a and b ): 30 print("5 - 变量 a 和 b 都为 false,或其中一个变量为 false") 31 else: 32 print("5 - 变量 a 和 b 都为 true")
输出结果:
1 1 - 变量 a 和 b 都为 true 2 2 - 变量 a 和 b 都为 true,或其中一个变量为 true 3 3 - 变量 a 和 b 有一个不为 true 4 4 - 变量 a 和 b 都为 true,或其中一个变量为 true 5 5 - 变量 a 和 b 都为 false,或其中一个变量为 false
- 成员运算符
运算符 | 描述 | 实例 |
---|---|---|
in | 如果在指定的序列中找到值返回 True,否则返回 False。 | x 在 y 序列中 , 如果 x 在 y 序列中返回 True。 |
not in | 如果在指定的序列中没有找到值返回 True,否则返回 False。 | x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。 |
如下实例:
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 a = 10 5 b = 20 6 list = [1, 2, 3, 4, 5 ]; 7 8 if ( a in list ): 9 print("1 - 变量 a 在给定的列表中 list 中") 10 else: 11 print("1 - 变量 a 不在给定的列表中 list 中") 12 13 if ( b not in list ): 14 print("2 - 变量 b 不在给定的列表中 list 中") 15 else: 16 print("2 - 变量 b 在给定的列表中 list 中") 17 18 # 修改变量 a 的值 19 a = 2 20 if ( a in list ): 21 print("3 - 变量 a 在给定的列表中 list 中") 22 else: 23 print("3 - 变量 a 不在给定的列表中 list 中")
输出结果:
1 1 - 变量 a 不在给定的列表中 list 中 2 2 - 变量 b 不在给定的列表中 list 中 3 3 - 变量 a 在给定的列表中 list 中
- 身份运算符
运算符 | 描述 | 实例 |
---|---|---|
is | is是判断两个标识符是不是引用自一个对象 | x is y, 如果 id(x) 等于 id(y) , is 返回结果 1 |
is not | is not是判断两个标识符是不是引用自不同对象 | x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1 |
如下实例:
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 a = 20 5 b = 20 6 7 if ( a is b ): 8 print("1 - a 和 b 有相同的标识") 9 else: 10 print("1 - a 和 b 没有相同的标识") 11 12 if ( id(a) == id(b) ): 13 print("2 - a 和 b 有相同的标识") 14 else: 15 print("2 - a 和 b 没有相同的标识") 16 17 # 修改变量 b 的值 18 b = 30 19 if ( a is b ): 20 print("3 - a 和 b 有相同的标识") 21 else: 22 print("3 - a 和 b 没有相同的标识") 23 24 if ( a is not b ): 25 print("4 - a 和 b 没有相同的标识") 26 else: 27 print("4 - a 和 b 有相同的标识")
输出结果:
1 1 - a 和 b 有相同的标识 2 2 - a 和 b 有相同的标识 3 3 - a 和 b 没有相同的标识 4 4 - a 和 b 没有相同的标识
- 运算符优先级
运算符 | 描述 |
---|---|
** | 指数 (最高优先级) |
~ + - | 按位翻转, 一元加号和减号 (最后两个的方法名为 [email protected] 和 [email protected]) |
* / % // | 乘,除,取模和取整除 |
+ - | 加法减法 |
>> << | 右移,左移运算符 |
& | 位 ‘AND‘ |
^ | | 位运算符 |
<= < > >= | 比较运算符 |
<> == != | 等于运算符 |
= %= /= //= -= += *= **= | 赋值运算符 |
is is not | 身份运算符 |
in not in | 成员运算符 |
not or and | 逻辑运算符 |
如下实例:
1 #!/usr/bin/env python 2 # -*- coding:UTF-8 -*- 3 4 a = 20 5 b = 10 6 c = 15 7 d = 5 8 e = 0 9 10 e = (a + b) * c / d #( 30 * 15 ) / 5 11 print("(a + b) * c / d 运算结果为:", e) 12 13 e = ((a + b) * c) / d # (30 * 15 ) / 5 14 print("((a + b) * c) / d 运算结果为:", e) 15 16 e = (a + b) * (c / d); # (30) * (15/5) 17 print("(a + b) * (c / d) 运算结果为:", e) 18 19 e = a + (b * c) / d; # 20 + (150/5) 20 print("a + (b * c) / d 运算结果为:", e)
输出结果:
1 (a + b) * c / d 运算结果为: 90.0 2 ((a + b) * c) / d 运算结果为: 90.0 3 (a + b) * (c / d) 运算结果为: 90.0 4 a + (b * c) / d 运算结果为: 50.0
2.2 集合
集合(set)是一个无序的,不重复的数据组合,它的主要作用如下:
- 去重:把一个列表变成集合,就自动去重了
- 关系测试:测试两组数据之前的交集、差集、并集等关
创建集合:
1 >>> name = {"James","Kobe","Yao","James"} 2 >>> print(name) 3 {‘Kobe‘, ‘James‘, ‘Yao‘} 4 >>> type(name) 5 <class ‘set‘>
或者:
1 >>> name = set({"James","Kobe","Yao","James"}) 2 >>> print(name) 3 {‘Kobe‘, ‘James‘, ‘Yao‘} 4 >>> type(name) 5 <class ‘set‘>
clear(self, *args, **kwargs)
清除内容
1 >>> name = {"James","Kobe","Yao","James"} 2 >>> print(name) 3 {‘Kobe‘, ‘James‘, ‘Yao‘} 4 >>> name.clear() 5 >>> print(name)清除内容 6 set()
copy(self, *args, **kwargs)
浅拷贝
1 >>> name1 = {"James","Kobe","Yao","James"} 2 >>> print(name1) 3 {‘Kobe‘, ‘James‘, ‘Yao‘} 4 >>> name2 = name1.copy() 5 >>> print(name2) 6 {‘Kobe‘, ‘James‘, ‘Yao‘} 7 >>> id(name1) 8 3082730828 9 >>> id(name2) 10 3082730268
difference(self, *args, **kwargs)
name2中存在,name1中不存在
1 >>> name1 = {"James","Kobe","Yao","James"} 2 >>> name2 = {"James","Henry","Ronaldo"} 3 >>> name2.difference(name1) 4 {‘Ronaldo‘, ‘Henry‘}
difference_update(self, *args, **kwargs)
从当前集合中删除和另一集合中相同的元素
1 >>> name1 = {"James","Kobe","Yao","James"} 2 >>> name2 = {"James","Henry","Ronaldo"} 3 >>> name2.difference_update(name1) 4 >>> print(name2) 5 {‘Ronaldo‘, ‘Henry‘}
discard(self, *args, **kwargs)
移除指定元素,不存在不报错
1 >>> name = {"James","Kobe","Yao"} 2 >>> name.discard("Kobe") 3 >>> print(name) 4 {‘James‘, ‘Yao‘}
intersection(self, *args, **kwargs)
交集
1 >>> name1 = {"James","Kobe","Yao"} 2 >>> name2 = {"James","Henry","Ronaldo"} 3 >>> name2.intersection(name1) 4 {‘James‘}
intersection_update(self, *args, **kwargs)
取交集并更新
1 >>> name1 = {"James","Kobe","Yao"} 2 >>> name2 = {"James","Henry","Ronaldo"} 3 >>> name2.intersection_update(name1) 4 >>> print(name2) 5 {‘James‘}
isdisjoint(self, *args, **kwargs)
如果没有交集,返回True,否则返回False
1 name1 = {"James","Kobe","Yao"} 2 name2 = {"James","Henry","Ronaldo"} 3 name2.isdisjoint(name1)
issubset(self, *args, **kwargs)
是否是子序列
1 >>> name1 = {"James","Kobe","Yao"} 2 >>> name2 = {"James"} 3 >>> name2.issubset(name1) 4 True
issuperset(self, *args, **kwargs)
是否是父序列
1 >>> name1 = {"James","Kobe","Yao"} 2 >>> name2 = {"James"} 3 >>> name1.issuperset(name2) 4 True
pop(self, *args, **kwargs)
移除元素
1 >>> name = {"James","Kobe","Yao"} 2 >>> name.pop() 3 ‘Kobe‘ 4 >>> print(name) 5 {‘James‘, ‘Yao‘}
remove(self, *args, **kwargs)
移除指定元素,若不存在,则报错
1 >>> name = {"James","Kobe","Yao"} 2 >>> name.remove("James") 3 >>> print(name) 4 {‘Kobe‘, ‘Yao‘}
symmetric_difference(self, *args, **kwargs)
对称差集
1 >>> name2 = {"James","Henry","Ronaldo"} 2 >>> name1 = {"James","Kobe","Yao"} 3 >>> name1.symmetric_difference(name2) 4 {‘Kobe‘, ‘Ronaldo‘, ‘Yao‘, ‘Henry‘}
symmetric_difference_update(self, *args, **kwargs):
对称差集并更新
1 >>> name2 = {"James","Henry","Ronaldo"} 2 >>> name1 = {"James","Kobe","Yao"} 3 >>> name1.symmetric_difference_update(name2) 4 >>> print(name1) 5 {‘Kobe‘, ‘Ronaldo‘, ‘Yao‘, ‘Henry‘} 6 >>>
union(self, *args, **kwargs)
并集
1 >>> name2 = {"James","Henry","Ronaldo"} 2 >>> name1 = {"James","Kobe","Yao"} 3 >>> name1.union(name2) 4 {‘Kobe‘, ‘James‘, ‘Ronaldo‘, ‘Yao‘, ‘Henry‘}
update(self, *args, **kwargs)
更新
1 >>> name2 = {"James","Henry","Ronaldo"} 2 >>> name1 = {"James","Kobe","Yao"} 3 >>> name1.update(name2) 4 >>> print(name1) 5 {‘Kobe‘, ‘James‘, ‘Ronaldo‘, ‘Yao‘, ‘Henry‘}
2.3 文件操作
open函数,该函数用于文件处理
操作文件时,一般需要经历如下步骤:
- 打开文件
- 操作文件
- 关闭文件
2.3.1 打开文件
打开文件时,需要指定文件路径和以何等方式打开文件,打开后,即可获取该文件句柄,通过此文件句柄对该文件操作。
文件句柄 = open("文件路径","模式")
打开文件的模式有:
- r ,只读模式【默认】
- w,只写模式【不可读;不存在则创建;存在则清空内容;】
- x, 只写模式【不可读;不存在则创建,存在则报错】
- a, 追加模式【可读; 不存在则创建;存在则只追加内容;】
"+" 表示可以同时读写某个文件
- r+, 读写【可读,可写】
- w+,写读【可读,可写】
- x+ ,写读【可读,可写】
- a+, 写读【可读,可写】
"b"表示以字节的方式操作
- rb 或 r+b
- wb 或 w+b
- xb 或 w+b
- ab 或 a+b
注:以b方式打开时,读取到的内容是字节类型,写入时也需要提供字节类型
程序:购物车程序
需求:
启动程序后,让用户输入工资,然后打印商品列表
允许用户根据商品编号购买商品
用户选择商品后,检测余额是否够,够就直接扣款,不够就提醒
可随时退出,退出时,打印已购买商品和余额
程序: 三级菜单
要求:
打印省、市、县三级菜单
可返回上一级
可随时退出程序
1
2
3
|
li = [ 11 , 22 , 33 , 44 ] for item in li: print item |
1
2
3
|
li = [ 11 , 22 , 33 ] for k,v in enumerate (li, 1 ): print (k,v) |
1
2
3
4
5
6
7
8
|
print range ( 1 , 10 ) # 结果:[1, 2, 3, 4, 5, 6, 7, 8, 9] print range ( 1 , 10 , 2 ) # 结果:[1, 3, 5, 7, 9] print range ( 30 , 0 , - 2 ) # 结果:[30, 28, 26, 24, 22, 20, 18, 16, 14, 12, 10, 8, 6, 4, 2] |
以上是关于Day02 Python 基本数据类型的主要内容,如果未能解决你的问题,请参考以下文章