• Day02

    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),"
", type(number_b), "
",type(number_c), "
",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	world".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（列表）。

    元组用"()"标识。内部元素用逗号隔开。但是元组不能二次赋值，相当于只读列表。

    创建元祖：
    　　ages = (11,22,33,44,55)
    　　或者
    　　ages = tuple((11,22,33,44,55))
     
    基本操作：
    • 索引
    • 切片
    • 循环
    • 长度
    • 包含
     
    如下实例：
     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组成。

    创建字典：
    　　person = {"name":"James","age":24}
    　　或者：
    　　person = dict({"name":"James","age":24})

    常用操作：

    • 索引
    • 新增
    • 删除
    • 键、值、键值对
    • 循环
    • 长度

    如下实例：

     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 没有相同的标识
    • 运算符优先级
    运算符描述
    ** 指数 (最高优先级)
    ~ + - 按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
    * / % // 乘，除，取模和取整除
    + - 加法减法
    >> << 右移，左移运算符
    & 位 '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、for循环
    用户按照顺序循环可迭代对象中的内容，
    PS：break、continue
    1
    2
    3
    li = [11,22,33,44]
    for item in li:
        print item
    2、enumrate
    为可迭代的对象添加序号
    1
    2
    3
    li = [11,22,33]
    for k,v in enumerate(li, 1):
        print(k,v)
    3、range和xrange
    指定范围，生成指定的数字
    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]　
  • 相关阅读:
    封装函数通过输入(元素，属性，目标值)改变div样式
    unicode键盘编码表
    js中的索引值
    JavaScript的三大组成部分
    阿望教你用vue写扫雷（超详细哦）
    关于换行以及换行属性
    html中的a标签详解
    利用GitHub Pages + jekyll快速搭建个人博客
    本博客文章转载，请注明出处
    git clone克隆项目太慢，或者直接导致克不下来的解决办法（转载请注明出处）
  • 原文地址：https://www.cnblogs.com/RUReady/p/5973900.html
Copyright © 2020-2023  润新知