Python 实验二上篇基础系列

  Python123 的第二次实验，我无法根据不同学校的老师授课情况的不同来讲述所有的题目，但是基础的知识是相同的。第二次的实验基本要学会 Python 的基本数据类型，以及对数据类型的不同操作。学习是一个丰富的过程，编程语言是一个呈现思维的方式，学的越多不光是解题的思路越多，更重要的是帮助我们用这种语言精炼编程。废话不多说，直接进入正题。

1.基本数据类型

  Python3 中有 6 个标准的数据类型：Number (数字)、String (字符串)、Tuple (元组)、List (列表)、Set (集合)、Dictionary (数组)。 其中前面三个是不可变数据，后面三个是可变数据。

1.1 Number (数字)

  Python3 支持四种数字：int、float、bool、complex（复数） int 不像 Java 规定有长整型和整型，Python3 只有一种 int 。另外数字型也同样可以做一些直观的运算，下面会讲，与 C 和 Java 少许不同。下面我们借助 type() 函数来查看数据对象的类型。

# 数字型
a = 1
b = 2.0
c = False
d = 4 + 5j
print(f'a 的数据类型：{type(a)}')
print(f'b 的数据类型：{type(b)}')
print(f'c 的数据类型：{type(c)}')
print(f'd 的数据类型：{type(d)}')

1
2
3
4
5
6
7
8
9
10

输出：如下

a 的数据类型：<class 'int'>
b 的数据类型：<class 'float'>
c 的数据类型：<class 'bool'>
d 的数据类型：<class 'complex'>

1
2
3
4
5

当然也可以用 instance()，但是 instance() 更多是用来判断类型是否相同。

a1 = 1
b1 = 2.0
c1 = 3
print(type(a1) == type(c1))
print(isinstance(a1, type(b1)))
1
2
3
4
5

输出是 true false。isinstance() 判断这个类型是否是父类型的子类型，type() 则不会，对象类型相同就返回true。此外，我们还需要注意在 Python3 中 bool 值是 int 型的子类。True 为1，False 为 2，并且可以相加减等运算。看这个例子：

a3 = True
b3 = False
c3 = True+4
print(a3)
print(b3)
print(c3)
1
2
3
4
5
6

输出结果：注意 True + 4 = 5

True
False
5
1
2
3

通过上面几个例子，我们可以发现一个共同点。Python 创建数字对象很容易，不需要指定类型：a = 1 就知道 a 是 int 型的对象。那么怎么删除呢？这个其实很多都没用到，反正我的同学就是只管创建不管删除。实际上删除使用 del 变量。

a4 = 2
print(a4)
del a4
print(a4)
1
2
3
4

输出结果：原因就是 a4 对象已被删除而报错。

  数值的7种运算：+ 、- 、（乘）、\ (除，非整除)、\ (整除) 、% （取余）、** 乘方。

a5 = 1 + 1
b5 = 2 - 2
c5 = 3 * 3
d5 = 4 / 3
e5 = 4 // 3
f5 = 5 % 3
g5 = 6 ** 6
print(a5, b5, c5, d5, e5, f5, g5)

输出：2 0 9 1.3333333333333333 1 2 46656
1
2
3
4
5
6
7
8
9
10

注意：// 整除 和 / 除，乘方 这里不同与C语言和Java

1.2 String（字符串）

  字符串中赋值不分 ’ ’ , " " 效果相同。链接字符串用 + ,复制或者重复用 *。字符串的讲解会结合数组来理解，掌握索引和分割就行了。
  下面按这张图展示的是索引，需要记住: 正向从零开始，反向从末尾开始。

来看看代码举例：

str1 = '桃花依旧笑春风。'
print(str1[0], str1[-1], str1[-2])

输出：
    桃 。 风
1
2
3
4
5

对照上面的索引图很容易看懂着行代码。我们通常习惯于正向，有时候需要逆向的索引用C和Java就比较繁琐。要获取长度定位最后一个字符索引，Python 只需要倒着从 -1 开始往前找就行了。
  其实索引在字符分割截取操作更能体现他的厉害。程序中已经揭示了一个信息：我们的字符串操作 str[0] 是不是就像是一个数组获取内容呢？我们对这个字符串截取只需要英文冒号 : 。规则说明：字符串还是 桃花依旧笑春风。

1. 方法使用格式：str[开始索引 : 结束索引 : 截取步长]
2. 这个区间是左闭右开。如：str[0:7] 就是：桃花依旧笑春风 没有了句号，等同于 str[0:-1]。如果 str[0:] 代表取完，结果加上句号。
3. 步长可以不用写，默认为一，在第二条已经体现出来了。当步长为二时 str[0: -1 :2] : 桃依笑风
   程序理解观摩，这里我把重复 * 和拼接 + 一起附上去，太简单了，一看就会，不会的就劝退转专业哦！(骗你的，其实这些都是基础，对于你们而言就真的是傻瓜知识了，但是真的不会，要么你是第一次接触或者前面的编程语言没学好那就认真学习，总要痛苦一次后面才会轻松嘛。)

str1 = '桃花依旧笑春风。'
str2 = '我笑你个der.'
print(str1[0:-1])       # 输出所有字符串，除去最后一个字符： 桃花依旧笑春风
print(str1[:-1])
print(str1[:-1:2])    # 在 除去最后一个字符串所剩下的所有字符中，从第一个字符开始，以后的字符索引要相差 2 这么个取法
print('重复的结果：'+str1*2)
print('拼接的结果: '+str1+str2)
1
2
3
4
5
6
7

1.3 List（列表）

  List 就有点东西啊，上面字符串拥有的特点，它全都具备，索引，截取，重复，拼接。但是我们学东西就要学不同的地方，这样你才能分辨谁是谁，你不能见到谁都说这是字符串，哪个也是，我只能说：朋友别裸泳啊！

1. 长相区别：字符串：str2 = ‘人面不知何处去，’ 列表: list2 = [‘桃’, ‘花’, 1, 9, ‘笑’, ‘春’, False] . 字符串用的是 ’ ’ 而 列表 [] 逗号隔开，更像数组。对其进行截取也是逗号相隔的整体。
2. 从上面创建对象不难看出，列表的成员更加丰富，可以是字符串，int，bool等值，不再像字符串那么单一。
3. List内容可变, 但是String 的内容不可变
4. List 还有一些操作手段，后面才讲，这里放一放。

代码观摩：注意截取内容，创建对象的内容

str2 = '人面不知何处去，'
list3 = list2 = ['桃', '花', 1, 9, '笑', '春', False]
list3[2] = str2 # 把list3的第三个元素改成str2对象
print('str2: '+str2)
print(f'\nlist2: {list2:}\n')
print(f'list3: {list3:}\n')
print(f'list2 截取：{list2[0:-1:2]:}\n')
print(f'list2 重复：{list2*2}')
1
2
3
4
5
6
7
8

输出结果：

1.4 Tuple（元组）

  这个还是跟 String 差不多，这里列出四个特点：

1. 创建对象：tuple1 = (‘吾’, 2, False, 1, ‘三’) 由括号括起来的，并且里面的成员可以是不同的类型对象，和 List 相同。
2. Tuple 对象一旦创建不可以改变，和 String 相同。
3. 索引，截取，拼接，重复任然适用
4. 空元组和 1 个元素的元组创建特殊
   代码观摩：

tuple1 = ('吾', 2, False, 1, '三')  # 我爱你一生
tuple2 = ()     # 空元组
tuple3 = ('兔兔',)    # 一个元素的元组
print(f'普通元组：{tuple1}\n')
print(f'空元组：{tuple2}\n')
print(f'一元素元组：{tuple3}')

输出：
    普通元组：('吾', 2, False, 1, '三')

    空元组：()

    一元素元组：('兔兔',)
1
2
3
4
5
6
7
8
9
10
11
12
13

在这里小结一下：String、List、Tuple。这三个数据类型多少有点相似，我们把它归到序列sequence里面。接下来要讲的集合Set，和字典Dictionary就不同了。

1.5 Set (集合)

  集合（set）是由一个或数个形态各异的大小整体组成的，构成集合的事物或对象称作元素或是成员。基本功能是进行成员关系测试和删除重复元素。可以使用大括号 { } 或者 set() 函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

1. 集合创建 set1 = {成员, 成员} 单元素也可以这样：set1 = set(成员) 。如果 set(成员) 没有 set ,你说它像元组但是元组成员后面多一个 ， 。
2. 集合可以做相应的运算，详见代码

set1 = set("去年路过此门中，")       # 单元素集合
set2 = {"门外桃花映样红。"}
set3 = {'I', 'love', 'kunkun', 666}
set4 = {666, '我', '爱', '坤坤'}
print(set1, set2)
print(f'\n集合的差集：{set3 - set4}')     # 颠倒位置可能导致结果不同
print(f'\n集合的并集：{set3 | set4}')
print(f'\n集合的不相交：{set3^set4}')
print(f'\n集合的交集：{set3 & set4}')

输出 ：
        {'中', '门', '过', '去', '此', '年', '路', '，'} {'门外桃花映样红。'}

        集合的差集：{'I', 'kunkun', 'love'}

        集合的并集：{'I', 'love', 'kunkun', '爱', '坤坤', 666, '我'}

        集合的不相交：{'I', 'love', '爱', 'kunkun', '坤坤', '我'}

        集合的交集：{666}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

1.6 Dictionary（字典）

  字典就有点类似于我们 Java 学的图这种数据结构，键值对构成的。无序排列，键唯一，必须使用不可变类型数据（开头已经提到了），值可变。字典是一种映射类型，{} 来标记。
代码：

dict1 = {'name': "四川兔兔", 'age': 100, 3: False}  # 创建一个字典
print(dict1)
print(f"\n键值为 name 的成员: {dict1['name']}")
print(f"\n所有的键：{dict1.keys()}")
print(f'\n所有的值：{dict1.values()}')

输出：
		{'name': '四川兔兔', 'age': 100, 3: False}

		键值为 name 的成员: 四川兔兔

		所有的键：dict_keys(['name', 'age', 3])

		所有的值：dict_values(['四川兔兔', 100, False])
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.总结

  作为一个初学者，这些只是了解是远远不够的，因为你很容易忘。我们通过刷题也只是加强记牢，要想得到质的提升，你得学会做点东西，用新的知识解决问题。开始这个比较混乱，没有去应用当让乱啊，学习要明白自己的目的，不要死磕，为什么记不住？有什么办法?能不能立刻执行？能坚持多久？想明白一个问题，立刻行动，别怕弯路多，走不通换路就好了。当你没有方向的时候，别害怕迷茫，没有方向就是最好的方向：你会花更多时间去探索，而那些路可能被前人探索，可能没有，没有探索的将是你大放光彩的地方。趁着年少，趁着清醒，多干点事儿吧。