python基础——持续更新中_rdd的创建 - python

（在有java的基础上，在学习python过程中进行知识点的整理，方便之后查阅~）

基础语法

1. 数据类型

1.1整型

除法：

• /：计算结果为浮点数
• //： 计算结果为整数

print(4/3)
print(4//3)
print(4//3.0)
1
2
3

结果为：
1.3333333333333333
1
1.0

1.2 浮点型

float类型

1.3 复数

复数由实数或虚数组成，可以用a+bj或complex(a,b)表示，复数的实部a和虚部b都是浮点型

1.4 数据类型转换

以下四个函数可进行类型转换

• int(x)
• float(x)
• complex(x)转换为一个复数，实部为x，虚部为0
• complex(x, y)转换为一个复数，实部为x，虚部为y

print(int(3.1415))
print(float(3))
1
2

结果为：
3
3.0

1.5 常量

PI：圆周率
E：数学常量e，即自然对数

2. 变量和关键字

变量：

• 必须赋值
• 字符串用引号
• 可反复赋值

检查变量类型方法：type()

a = 123
print(type(a))
a = 'python'
print(type(a))
1
2
3
4

结果为：
<class ‘int’>
<class ‘str’>
变量命名规范

• 首字母必须是字母
• 不能包含关键字

3. 运算符和操作对象

算术运算符

比较运算符

赋值运算符

赋值运算符

print(a<<1)
print(a>>1)
1
2

结果为：
8
2

赋值运算符

成员运算符

list = [1,2,3,4,5]
print(2 in list)
print(100 in list)

print(2 not in list)
print(100 not in list)
1
2
3
4
5
6

结果为：
True
False
False
True

身份运算符
身份运算符是用于比较两个对象的存储单元

a = 10
b = 10
print(a is b)
print(a is not b)

b = 20
print(a is b)
print(a is not b)
1
2
3
4
5
6
7
8

结果为：
True
False
False
True

4. 字符串操作

字符串用 ‘ 或者“创建字符串，可用+做字符串拼接

实例：九九乘法表实现

for i in range(1,10):
    for j in range(1,i+1):
        print("%d*%d=%d"%(i,j,i*j),end=' ')
    print(' ')
1
2
3
4

结果为：
1*1=1  
2*1=2 2*2=4  
3*1=3 3*2=6 3*3=9  
4*1=4 4*2=8 4*3=12 4*4=16  
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25  
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36  
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49  
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64  
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
1
2
3
4
5
6
7
8
9
10

5. 列表和元组

5.1 通用序列操作

5.1.1 索引

序列中的元素的索引都是从0开始递增的

a = 'HELLO'
print(a[0])
print(a[2])
1
2
3

结果为：
H
L

也可以从右往左获取元素：

a = 'HELLO'
print(a[-1])
print(a[-2])
1
2
3

结果为：
O
L
注意：0和-0都指向第一个元素
可以直接对索引进行操作

print('请输入一句话: ')
thirdth = input()[0]
print(thirdth)
1
2
3

结果为：
请输入一句话:
你好呀
你

5.1.2 分片

索引用来对单个元素进行访问，使用分片可以对一定范围内的元素进行访问

number = [1,2,3,4,5,6,7,8,9,10]
print(number[1:3])
print(number[-3:-1])
1
2
3

结果为：
[2, 3]
[8, 9]

• 分片即支持正数索引，也支持负数索引
• [a:b] 类似与a<= x < b，b不包含在x的范围内

number = [1,2,3,4,5,6,7,8,9,10]
print(number[:])
print(number[0:])
print(number[-3:])
print(number[:3])
print(number[:-3])
1
2
3
4
5
6

结果为：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[8, 9, 10]
[1, 2, 3]
[1, 2, 3, 4, 5, 6, 7]

• 引入步长的概念：[a : b : c]，c为步长，可为正负数，步长不能为0

number = [1,2,3,4,5,6,7,8,9,10]
print(number[::2])
print(number[::-1])
print(number[::-2])
1
2
3
4

结果为：
[1, 3, 5, 7, 9]
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
[10, 8, 6, 4, 2]

5.1.3 序列相加

print([1, 2, 3]+[4, 5, 6])
a = [1, 2]
b = [5, 6]
print(a + b)
a = 'hello'
b = 'word'
print(a + b)
1
2
3
4
5
6
7

结果为：
[1, 2, 3, 4, 5, 6]
[1, 2, 5, 6]
helloword

5.1.4 序列相乘

print('hello'*5)
print([7]*10)
1
2

结果为：
hellohellohellohellohello
[7, 7, 7, 7, 7, 7, 7, 7, 7, 7]

5.1.5 长度、最小值和最大值

三个函数使用方法

number = [300, 100, 200, 800, 500]
print(len(number))
print(max(number))
print(min(number))
print(max(1, 2, 3, 4, 5, 5, 5))
print(min(1, 2, 3, 4, 5, 5, 5))
1
2
3
4
5
6

结果为：
5
800
100
5
1

5.2 列表

5.2.1 更新列表

1. 元素赋值

number = [300, 100, 200, 800, 500]
number[1] = 'hello'
print(type(number))
print(number)
print(type(number[1]))
print(type(number[2]))
1
2
3
4
5
6

结果为：
<class ‘list’>
[300, ‘hello’, 200, 800, 500]
<class ‘str’>
<class ‘int’>
注意：不能为一个不存在元素的位置赋值

2. 增加元素
list.append(obj)
list代表列表，obj代表需要添加到list列表末尾的对象

number = [300, 100, 200, 800, 500]
number.append('xixixi')
print(number)
1
2
3

结果为：
[300, 100, 200, 800, 500, ‘xixixi’]

3. 删除元素
del list[index]

number = [300, 100, 200, 800, 500]
del number[1]
print(number)
1
2
3

结果为：
[300, 200, 800, 500]

4. 分片赋值
list()函数：可以直接将字符串转换为列表

list()函数和分片赋值的使用：

a = list('女排夺冠了')
print(a)
a[3:] = list('什么啦？')
print(a)
a[2:6] = []
print(a)
1
2
3
4
5
6

结果为：
[‘女’, ‘排’, ‘夺’, ‘冠’, ‘了’]
[‘女’, ‘排’, ‘夺’, ‘什’, ‘么’, ‘啦’, ‘？’]
[‘女’, ‘排’, ‘？’]

5. 嵌套列表

a=['a', 'b', 'c']
b = [1, 2, 3]
mix = [a, b]   
print(mix)
print(mix[0])
print(mix[1])
1
2
3
4
5
6

结果为：
[[‘a’, ‘b’, ‘c’], [1, 2, 3]]
[‘a’, ‘b’, ‘c’]
[1, 2, 3]

6. 列表方法

(1) append
功能：在列表的末尾添加新对象
list.append(obj)

(2) count
list.count(obj)
用于统计某个元素在列表中出现的次数（liist代表列表，obj代表列表中统计的对象）

a=['a', 'b', 'c', 'c']
print(a.count('c'))

# 嵌套列表
mix = [[1, 3], 2, 4, [1, 3]]
print(('嵌套列表mix中列表[1，3]的个数为：%d' %mix.count([1,3])))
1
2
3
4
5
6

结果为：
2
嵌套列表mix中列表[1，3]的个数为：2

(3) extend
功能：将一个序列增加到另一个序列的末尾
语法：list.extend(seq)
list代表被扩展的列表，seq代表追加到list末尾的列表

a = ['hello', 'world']
b = ['python', 'is', 'funny']
a.extend(b)
1
2
3

结果为：
[‘hello’, ‘world’, ‘python’, ‘is’, ‘funny’]

(4) index
功能：从列表中找到某个值第一个匹配项的索引项目
语法：list.index(obj)
list代表列表，obj代表要查找的对象

field = ['hello', 'world', 'python', 'is', 'funny']
print('hello 的索引位置：', field.index('hello'))
print('python 的索引位置：', field.index('python'))
1
2
3

hello 的索引位置： 0
python 的索引位置： 2

(5) insert
功能：用于将对象插入列表
语法：list.insert(index, obj)
list代表列表，index代表插入对象obj需要插入的索引位置

field = ['hello', 'world', 'python', 'is', 'funny']
print('插入之前的num：', field)
field.insert(2, 'hahahaha')
print('插入之后的num：', field)
1
2
3
4

结果为：
插入之前的num： [‘hello’, ‘world’, ‘python’, ‘is’, ‘funny’]
插入之后的num： [‘hello’, ‘world’, ‘hahahaha’, ‘python’, ‘is’, ‘funny’]

(6) pop
功能：移除列表中的一个元素(默认最后一个元素)，并且返回该元素的值
语法：list.pop(obj=list[-1])
list代表列表，obj为可选择的参数，代表要移除列表元素的对象

field = ['hello', 'world', 'python', 'is', 'funny']
print(field.pop())
print('移除元素后的field: ', field)
field.pop(3)
print('移除元素后的field: ', field)
field.pop(0)
print('移除元素后的field: ', field)
1
2
3
4
5
6
7

结果为：
funny
移除元素后的field: [‘hello’, ‘world’, ‘python’, ‘is’]
移除元素后的field: [‘hello’, ‘world’, ‘python’]
移除元素后的field: [‘world’, ‘python’]

注意：pop是唯一一个既能修改列表又能返回元素值（除了None外）的列表方法

使用pop可以实现一种常用的数据结构——栈：可以用pop()不传参默认移除最后一位来模拟栈先进后出的操作

num = [1, 2, 3]
num.append(num.pop())
print('num追加出栈值的操作结果：', num)
1
2
3

结果为：
num追加出栈值的操作结果： [1, 2, 3]

解释：先执行num.pop()，执行过后num的值为[1, 2]，num.pop()的值为3，使用num.append()方法将3添加到[1, 2]末尾，最后得到的值为[1, 2, 3]

(7) remove
功能：remove方法用于移除列表中某个值的第一个匹配项
语法：list.remove(obj)
list代表列表，obj为列表中要移除的对象

field=['女排', '精神', '中国', '精神', '学习', '精神']
print('移除前列表field：', field)
field.remove('精神')
print('移除后列表field：', field)
1
2
3
4

结果为：
移除前列表field： [‘女排’, ‘精神’, ‘中国’, ‘精神’, ‘学习’, ‘精神’]
移除后列表field： [‘女排’, ‘中国’, ‘精神’, ‘学习’, ‘精神’]

(8) reverse
功能：反向列表中的元素（reversed可以将结果返回）
语法：list.reverse()
list代表列表，该方法不需要传入参数

num=[1, 2, 3]
num=[3, 8, 4, 1, 5, 9]
print('列表反转前num：', num)
print(num.reverse())
print('列表反转后num：', num)
print(list(reversed(num)))
1
2
3
4
5
6

结果为：
列表反转前num： [3, 8, 4, 1, 5, 9]
None
列表反转后num： [9, 5, 1, 4, 8, 3]
[3, 8, 4, 1, 5, 9]

(9) sort
功能：用于对原本列表进行排序（sorted可直接获取返回值）
语法：list.sort(func)
list代表列表，func代表可选参数。如果指定该参数，就会使用该参数的方法进行排序

num=[3, 8, 4, 1, 5, 9]
print('列表反转前num：', num)
num.sort()
print('列表反转后num：', num)
1
2
3
4

结果为：
列表反转前num： [3, 8, 4, 1, 5, 9]
列表反转后num： [1, 3, 4, 5, 8, 9]

(10）clear
功能：用于清空列表，类似于del a[:]
语法：list.clear()
list代表列表，不需要穿传入参数

num=[3, 8, 4, 1, 5, 9]
print('清除前的num：', num)
num.clear()
print('清除后的num：', num)
1
2
3
4

结果为：
清除前的num： [3, 8, 4, 1, 5, 9]
清除后的num： []

(11）copy
功能：用于复制列表
语法：list.copy()
list代表列表，不需要传入参数

num=[3, 8, 4, 1, 5, 9]
print('num：', num)
copyNum = num.copy()
print('copyNum：', num)
1
2
3
4

结果为：
num： [3, 8, 4, 1, 5, 9]
copyNum： [3, 8, 4, 1, 5, 9]

(12) 高级排序
自定义比较方法排序：sort方法有两个可选参数，即key和reverse。

num=['study', 'python', 'is', 'happy']
print('排序前的num：', num)
num.sort(key=len) #按字符串长度从短到长排序
print('排序后的num：', num)

num=['study', 'java', 'is', 'happy']
print('排序前的num：', num)
num.sort(key=len, reverse=True)#按字符串长度长到短排序
print('排序后的num：', num)

num = [3, 4, 2, 5, 1]
print('排序前的num：', num)
num.sort(reverse=True) #排序后逆序
print('排序后的num：', num)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

结果为：
排序前的num： [‘study’, ‘python’, ‘is’, ‘happy’]
排序后的num： [‘is’, ‘study’, ‘happy’, ‘python’]
排序前的num： [‘study’, ‘java’, ‘is’, ‘happy’]
排序后的num： [‘study’, ‘happy’, ‘java’, ‘is’]
排序前的num： [3, 4, 2, 5, 1]
排序后的num： [5, 4, 3, 2, 1]

5.3 元组

5.3.1 元组的创建

元组跟列表类似，不同之处在于元组的元素不能修改（字符串的元素也不能修改），创建元组的方法就是使用逗号分隔一些值，就会自动创建元组，每个值后面必须跟一个逗号，例如（1，）
元组的创建实例：

n=(1,2,3)#创建多个值的元组
print(n)

n = ()#创建空元组
print(n)

n = (1,)#创建1个值的元组
print(n)
1
2
3
4
5
6
7
8

结果为：
(1, 2, 3)
()
(1,)

3.3.2 tuple函数

tuple函数功能和list函数基本是一样的，以一个序列作为参数，并把它转换成元组，如果参数是元组，参数会被照原样返回

num=['study', 'python', 'is', 'happy']
print(tuple(num))
print(tuple(['study', 'python', 'is', 'happy']))
print(tuple('hello'))
print(tuple(('hello', 'world'))) #参数为元组
1
2
3
4
5

结果为：
(‘study’, ‘python’, ‘is’, ‘happy’)
(‘h’, ‘e’, ‘l’, ‘l’, ‘o’)
(‘hello’, ‘world’)

3.3.3 元组的基本操作

1. 访问元组

可以使用下索标引访问元组中的值

num=['study', 'python', 'is', 'happy']
print("num[1] is: " ,num[1])
print("num[1:3] is: ", num[1:3])
1
2
3

结果为：
num[1] is: python
num[1:3] is: [‘python’, ‘is’]

2. 修改元组

元组中元素的值不允许修改，但是可以对元组进行连接组合，例如：

num1=('study', 'python')
num2=('is', 'happy')
num3=(2018,2019)
print("合并结果为: " ,num1+num2+num3)
1
2
3
4

结果为：
合并结果为: (‘study’, ‘python’, ‘is’, ‘happy’, 2018, 2019)

3. 删除元组

元组中的元素不允许删除，但是可以通过del语句删除整个元组，例如：

num = ('study', 'python', 'is', 'happy', 2018, 2019)
del num
print(num)
1
2
3

结果为：
NameError: name ‘num’ is not defined

4. 元素索引、截取

num = ('study', 'python', 'is', 'happy', 2018, 2019)

print(num[2])
print(num[-2])
print(num[1:])
print(num[-1:])
1
2
3
4
5
6

结果为：
is
2018
(‘python’, ‘is’, ‘happy’, 2018, 2019)
(2019,)

5.元组其他内置函数

（1）len(tup)
（2）max(tup)
（3）min(tup)
（4）seq(tup)

3.4 列表与元组的区别