本篇文章给大家谈谈python的基本语法及数据分析应用，以及python的基本语法元素有哪些，希望对各位有所帮助，不要忘了收藏本站喔。
Source code download: 本文相关源码
目录
程序的基本编写方法
输入
- 文件输入、网络输入、控制台输入、交互界面输入、内部参数输入等
- 输入是一个程序的开始
处理
- 处理是程序对输入数据进行计算产生输出结果的过程
- 处理方法统称为算法，它是程序最重要的部分
- 算法是一个程序的灵魂
输出
- 控制台输出、图形输出、文件输出、网络输出、操作系统内部变量输出等
- 输出是程序展示运算结果的方式
程序语法元素分析
程序的格式框架
1) 缩进
严格明确：缩进是语法的一部分，缩进不正确程序运行错误
所属关系：表达代码间包含和层次关系的唯一手段
长度一致：程序内一致即可，一般用4个空格或1个TAB
2) 注释
单行注释：以#开头，其后内容为注释
# 这是单行注释多行注释：以'''开头和结尾
''' 这是多行注释的第一行
这是多行注释的第二行 '''命名与保留字
1） 变量
变量采用标识符(名字) 来表示，关联标识符的过程叫命名
可以使用等号(=)向变量赋值或修改值，=被称为赋值符号
2） 命名
命名规则: 大小写字母、数字、下划线和中文等字符及组合
注意事项: 大小写敏感、首字符不能是数字、不与保留字相同
3) 保留字
Python语言有35个保留字(也叫关键字
保留字是编程语言的基本单词，大小写敏感
所有的保留字，如下表所示：
表一 保留字
| and | as | assert | break | class | continue |
| def | del | elif | else | except | finally |
| for | from | False | global | if | import |
| in | is | lambda | nonlocal | not | None |
| or | pass | raise | return | try | True |
| while | with | yield |
数据类型
1）整形
整形：int
2）浮点型
浮点型：float
3）布尔型
布尔型：bool
只有True和False，表示真假
4）复数类型（python特有的数据类型）
复数：complex
1.用实数加减（实数+j)来表示
a = 3-4j2.用complex（）函数来表示
a = complex(3,-4)序列
访问模式
- 正向递增：从0开始
- 反向递减：从-1开始
相关操作
标准类型运算符，主要进行的是值比较、对象身份比较和布尔运算，具体使用在之后介绍，大概的运算符如下所示：
值比较
| < | > |
| <= | > |
| == | != |
对象身份比较
| is | is not |
布尔运算
| not | and | or |
序列类型运算符，主要是一些序列特殊的运算符，具体如下所示：
| x in s | x not in s | s + t | s * n, n * s |
| s[i] | s[i:j] | s[i:j:k] | s[::-1] |
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
print(week[1], week[-2], '\n', week[1:4], '\n',week[:6], '\n',
week[::-1], '\n', week[-5:], '\n', week[1:-1], '\n', week[0:7:2])输出结果如下所示：
['Tuesday', 'Wednesday', 'Thursday']
['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
['Sunday', 'Saturday', 'Friday', 'Thursday', 'Wednesday', 'Tuesday', 'Monday']
['Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
['Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
['Monday', 'Wednesday', 'Friday', 'Sunday']
序列类型转换内建函数,可以将序列的类型进行转换，主要有，list()、str()和tuple()。
序列类型其他常用内建函数，可以对序列进行操作，在序列中使用非常方便和频繁，利用得当可以使我们的代码更简洁，高效，如下所示：
| enumerate() | reversed() | len() | sorted() |
| max() | sum() | min() | zip() |
aStr = 'Hello, World!'
print(len(aStr)) #输出结果为 13
print(sorted(aStr))
#运行结果为 [' ', '!', ',', 'H', 'W', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r']1）字符串
字符串：str
有引号引起来的就是字符串，单，双，三引号都行（与C有区别），具体代码如下所示：
s1 = "I'm a student"
print(s1)
s2 = "'hello " \
"world'"
print(s2)
s3 = r'd:\test\a.txt'
print(s3)运行结果如下所示
I'm a student
'hello world'
d:\test\a.txt
类型说明符：
| b | 二进制，以2为基数输出数字 |
| o | 八进制，以8为基数输出数字 |
| x | 十六进制，以16为基数输出数字，9以上的数字用小写字母（类型 符为X时用大写字母）表示 |
| c | 字符，将整数转换成对应的Unicode字符输出 |
| d | 十进制整数，以10为基数输出数字 |
| f | 浮点数，以浮点数输出数字 |
| e | 指数记法，以科学计数法输出数字，用e（类型符是E时用大写E） 表示幂 |
常用格式说明符：
| +m.nf | 输出带符号（若正整数输出“+”号）的数，保留n位小数，整个输出占 m列（若实际宽度超过m则突破m的限制） |
| < | 左对齐，默认用空格填充右边 |
| 0>5d | 右对齐，用0填充左边，宽度为5 |
| ^ | 居中对齐 |
| {{}} | 输出一个{} |
大体输出格式为：[对齐说明符][符号说明符][最小宽度说明符][.精度说明符][类型说明符]
实例如下：
age, height = 21, 1.758
print("Age:{0:^5d}, Height:{1:5.2f}".format(age, height))
#输出结果为 Age: 21 , Height: 1.76字符串与输出形式：
Python中有多种输出方式，目前提供几种常见的输出形式，代码如下：
1.用format函数格式化字符串：
name = ['A', 'B', 'C', 'D', 'E',]
score = ['100', '106', '500', '10', '100']
for i in range(5):
print('{:<8d}{:8s}{:8s}'.format(i, name[i], score[i]))
print('I get {:d}{{}}!'.format(100))输出结果如下所示：
0 A 100
1 B 106
2 C 500
3 D 10
4 E 100
I get 100{}!
2.格式化字符串f-string
x, y = 3, 5.678
print(f"x = {x}, y = {y:.2f}") #用F来表示也可以，如print(F"x={x}, y={y:.2f}")输出结果如下所示：
x = 3, y = 5.68
除此之外，f-string还支持表达式和函数调用，代码实现如下：
x = 3
print(f"{x*4 + 5}")
s = 'Hello'
print(f'{s.lower()}')输出结果如下所示：
17
hello
字符串的应用：
字符串有许多的方法提供给我们使用，可以让我们快速方便的解决一些问题，此处只展示一小部分方法的使用，代码如下所示：
#第一种做法
str = "abcdcba"
if (str == ''.join(reversed(str))): #reversed方法用来逆序字符串，返回值是reversed类型
print('Yes') #join方法用来连接字符串，让reversed类型变成str类型
else:
print('No')
#第二种做法
str = "abcdcba"
if (str == str[::-1]):
print('Yes')
else:
print('No')
#第三种做法
import operator
sStr = "acdhdca"
if operator.eq(sStr, ''.join(reversed(sStr))) == 1: #使用operator.eq方法来判断是否相等
print('Yes')
else:
print('No')
str = "abcdcba"
print(type(reversed(str)))
print(type(''.join(reversed(str))))输出结果如下所示：
Yes
Yes
Yes<class 'reversed'>
<class 'str'>
其他字符串方法，在此就不展开讲述具体用法，代码如下：
s = "Blowing in the wind"
print(s.find("the")) #find方法，用来查找字符串，加参数表示在此范围内查找
print(s.find("the", 1, 14))
print(s.lower()) # lower方法，把字符串变成小写
print(s.split(' ')) # split方法，按照参数切割字符串，返回一个列表
print(s.replace("the", "that")) # replace方法，替换字符串
alist = ["hello", "world"]
print(' '.join(alist))
y = '叶'
z = y.encode('utf-8') # encode方法，对字符串编码
x = b'\xe6\x89\x8e\xe5\xbf\x83\xe4\xba\x86\xef\xbc\x8c\xe8\x80\x81\xe9\x93\x81'
print(z)
t = x.decode() # decode方法，对字符串解码
print(t)
运行结果如下所示：
11
11
blowing in the wind
['Blowing', 'in', 'the', 'wind']
Blowing in that wind
hello world
b'\xe5\x8f\xb6'
扎心了，老铁
转义字符：
| \0 | 空字符 | \t | 横向制表符 | \f | 换页 | \" \' | 双(单）引号 |
| \a | 响铃 | \n | 换行 | \r | 回车 | \\ | 反斜杠 |
| \b | 退格 | \v | 纵向制表符 | \e | 转义 | \ | 续行符 |
用法同C语言类似，在此次不再赘述python实现猴子跳台阶。
序号：
- 正向递增：从0开始
- 反向递减：从-1开始
使用：
- 索引：<字符串>[M]（取出第M个）
- 切片：<字符串>[M：N]（取出第M，M+1个，但不到第N个）
- 重复：a*10
具体代码如下所示：
aStr = "Hello,World"
bStr = aStr[:6]+'python!'
count = 0
for ch in bStr[:]:
if ch in ',.!?':
count += 1
print(count)
print(bStr)
# 输出结果如下所示
#2 #程序中共有 2 个标点符号
#Hello,python! #字符串被替换2）列表
列表：list（有序，可变）
定义：
1.直接定义
li = [1,13,3-4j,"abcd"]2.赋值定义
[a,b,c]=[100,12,13]3.联合
a=[100,12,13]
b=[1,2,3]
c=a+b
print(c)运行结果：
取值：
访问下标：
a=[100,12,13]
b=a[0]
print(b)运行结果：
删除：
1.删除元素
a=[100,12,13]
del a[0]
print(a)运行结果：
2.删除列表
a=[100,12,13]
del a
print(a)运行结果：
添加：
1.在末尾添加
a=[100,12,13]
a.append(1)
print(a)
运行结果：
2.任意位置
a=[100,12,13]
a.insert(1,3)
print(a)运行结果：
列表的一些方法，代码如下：
pScore = [9, 9, 8.5, 10, 7, 8, 8, 9, 8, 10] #计算观众和评委的打分平均值
gScore = 9
pScore.sort() #pop方法，用于移除一个元素，默认最后一个
pScore.pop()
pScore.pop(0)
pScore.append(gScore) #append方法，添加元素
aveScore = sum(pScore)/len(pScore) #sum方法，求和
print(aveScore) #len方法，求长度运行结果如下所示：
8.722222222222221
week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
weekend = ['Saturday', 'Sunday']
week.extend(weekend) #连接列表以及输出列表
for i, j in enumerate(week):
#print(i+1, j)
print(f'{i+1}: {j}')运行结果如下所示：
1: Monday
2: Tuesday
3: Wednesday
4: Thursday
5: Friday
6: Saturday
7: Sunday
list1 = ['cc', 'a', 'r', 'bbbb']
list2 = [9, 2, 5, 4, 3] #排序
list1.sort(key=len) #按长度排序
list2.sort(reverse=False) #True,从大到小
print(list1)
print(list2)运行结果如下所示：
['a', 'r', 'cc', 'bbbb']
[2, 3, 4, 5, 9]
列表解析：
一般是在需要改变列表，而不是需要新建某个列表的时候可以使用它，是由多个for循环以及可迭代的序列构成，代码如下所示：
a = [x for x in range(10)]
print(a)
b = [x ** 2 for x in range(10)]
print(b)
c = [x ** 2 for x in range(10) if x ** 2 < 50]
print(c)
d = [(x + 1, y + 1) for x in range(3) for y in range(3)]
print(d)
e = sum(x for x in range运行结果如下所示：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
[0, 1, 4, 9, 16, 25, 36, 49]
[(1, 1), (1, 2), (1, 3), (2, 1), (2, 2), (2, 3), (3, 1), (3, 2), (3, 3)]
10
一个用来清除非英文的小程序，代码如下 ：
def clean_list(lst):
cleanded_list = []
for item in lst:
for c in item:
if c.isalpha() != True: # isalpha方法，判断是否是字母
item = item.replace(c, '') #替换
cleanded_list.append(item) #添加元素
return cleanded_list
old_list = ['12edsdsde', 'yifasdadwe-0', 'dejawdd#', 'a!mdawcm%']
new_list = clean_list(old_list)
#print(new_list)
for k, v in zip(range(1, len(new_list)+1), new_list):
print(k, v)运行结果如下所示：
1 edsdsde
2 yifasdadwe
3 dejawdd
4 amdawcm
3）元组
元组：tuple（有序，不可变）
定义：
1.直接定义
tp = ('a','b','c')2.赋值定义
(a,b,c)=(100,12,13)3..联合
a=(100,12,13)
b=(2,)
c=a+b
print(c)运行结果：
注：当元组里只有一个元素时，末尾要加，
取值：
访问下标：
a=(100,12,13)
b=a[0]
print(b)运行结果：
删除：
只能删除整个元组
a=(100,12,13)
del a
print(a)运行结果：
转换：
通过 set() 函数转换为集合
方法：
aTuple = (3, 5, 2, 4)
a = sorted(aTuple) #元组没有sort函数，也说明它是不可变的
print(a) #sorted函数返回一个列表运行结果如下所示：
[2, 3, 4, 5]
做可变长位置参数（元组）和返回值：
def fo(args1, *args): #多个参数可以构成一个元组作为函数的参数
print(args1)
print(args)
fo('12edsdsde', 'yifasdadwe-0', 'dejawdd#', 'a!mdawcm%')运行结果如下所示：
12edsdsde
('yifasdadwe-0', 'dejawdd#', 'a!mdawcm%')#多个参数当成元组
返回多个参数，代码如下：
def foo():
return 1, 2, 3 #同其他语言有明显的区别
print(foo()) #返回值是一个元组运行结果如下所示：
(1, 2, 3)
4）集合
集合：set【无序，不可重复（去重）】
分为可变集合（set）和不可变集合（frozenset）；不可变集合，顾名思义不能改变，和元组类似。
比较：
| 属于 | in | 不属于 | not in | 等于 | == | 不等于 | ！= |
| ⊂ | < | ⊆ | <= | ⊃ | > | ⊇ | >= |
代码如下：
aSet = set('sunrise')
bSet = set('sunset')
print('u' in aSet)
print(aSet == bSet)
print(aSet < bSet)
print(set('sun') < aSet)
输出结果：
True
False
False
True
运算：
- 交集：&
- 并集：|
- 差集：-（保留左侧独有的内容）
a={100,12,13}
b={100,12,1}
c=a-b
print(c)运行结果：
- 余集:^（去掉相同元素）
a={100,12,13}
b={100,12,1}
c=a^b
print(c)运行结果：
转换：
通过 list() 函数转换为列表
方法：
集合有较多的方法，在此举一部分例子，代码如下：
#所有集合都有的方法
aSet = set('sunrise')
bSet = set('sunset')
print(aSet.issubset(bSet)) #判断子集
print(aSet.intersection(bSet)) #取交集
print(aSet.difference(bSet)) #取差集
cSet = aSet.copy() #复制
print(cSet)
#可变集合才有的方法
aSet.add('!') #添加元素
print(aSet)
aSet.remove('!') #删除元素
print(aSet)
aSet.update('Yeah') #添加大量元素
print(aSet)
aSet.clear() #清除集合
print(aSet)运行代码如下所示：
False
{'u', 's', 'n', 'e'}
{'r', 'i'}
{'r', 's', 'i', 'u', 'n', 'e'}
{'r', 'i', 'n', 'e', '!', 's', 'u'}
{'r', 'i', 'n', 'e', 's', 'u'}
{'r', 'i', 'n', 'e', 'h', 's', 'Y', 'u', 'a'}
set()
5）字典
字典：dict
通过键值对存储数据(键具有唯一性）
定义：
1.直接定义，代码如下：
aInfo = {'Wangdachui': 3000, 'Niuyun':2000, 'Linling':4500, 'Tianqi':8000}
info = [('Wangdachui',3000), ('Niuyun',2000), ('Linling',4500), ('Tianqi',8000)]
bInfo = dict(info)
cInfo = dict([['Wangdachui',3000], ['Niuyun',2000], ['Linling',4500], ['Tianqi',8000]])
dInfo = dict(Wangdachui=3000, Niuyun=2000, Linling=4500, Tianqi=8000)
eInfo = dict((('Wangdachui',3000), ('Niuyun',2000), ('Linling',4500), ('Tianqi',8000)))
print(aInfo, type(aInfo))
print(bInfo, type(aInfo))
print(cInfo, type(aInfo)) #python支持多种方法定义字典
print(dInfo, type(aInfo))
print(eInfo, type(aInfo))运行结果如下所示：
{'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000} <class 'dict'>
{'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000} <class 'dict'>
{'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000} <class 'dict'>
{'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000} <class 'dict'>
{'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000} <class 'dict'>
2.一次给多个变量赋相同的值，代码如下：
aDict = {}.fromkeys(('Wangdachui','Niuyun', 'Linling', 'Tianqi'), 3000)
print(aDict)运行结果如下所示：
{'Wangdachui': 3000, 'Niuyun': 3000, 'Linling': 3000, 'Tianqi': 3000}
3.通过zip函数将两个列表一一对应，变成字典，代码如下所示：
names = ['Wangdachui', 'Niuyun', 'Linling', 'Tianqi']
salaries = [3000, 2000, 4500, 8000]
aDict = dict(zip(names, salaries))
print(aDict)运行结果如下所示：
{'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000}
pList = [('AXP', 'American Express Company', '78.51'), ('BA', 'The Boeing Company', '184.76'),
('CAT', 'Caterpillar Inc.', '96.39'), ('CSCO', 'Cisco Systems,Inc.', '33.71'),
('CVX', 'Chevron Corporation', '106.09')]
aList = []
bList = []
for i in range(5):
aStr = pList[i][0]
bStr = pList[i][2] #将一组数据的一部分拿出来形成字典
aList.append(aStr)
bList.append(bStr)
aDict = dict(zip(aList, bList))
print(aDict)运行结果如下所示：
{'AXP': '78.51', 'BA': '184.76', 'CAT': '96.39', 'CSCO': '33.71', 'CVX': '106.09'}
取值：
1.通过键名
a = {"a1":"123","a2":"234","b1":"345","b2":"456"}
b=a['a1']2.通过get函数
a = {"a1":"123","a2":"234","b1":"345","b2":"456"}
b=a.get("a1",1)
print(b)运行结果：
123
注：若是字典a中包含键"a1"，则返回键"a1"的键值，若不包含键"a1"，则返回1,若是不设置第二个参数，则默认返回None
更改：
a = {"a1":"123","a2":"234","b1":"345","b2":"456"}
a["a2"]=1
print(a)运行结果：
{'a1': '123', 'a2': 1, 'b1': '345', 'b2': '456'}
添加:
a = {"a1":"123","a2":"234","b1":"345","b2":"456"}
a["a3"]=1
print(a)运行结果：
{'a1': '123', 'a2': '234', 'b1': '345', 'b2': '456', 'a3': 1}
删除：
1.删除元素
a = {"a1":"123","a2":"234","b1":"345","b2":"456"}
del a["a1"]
print(a)运行结果：
{'a2': '234', 'b1': '345', 'b2': '456'}
2.删除字典
a = {"a1":"123","a2":"234","b1":"345","b2":"456"}
del a
print(a)运行结果：
3.清除字典：
a = {"a1": "123", "a2": "234", "b1": "345", "b2": "456"}
a.clear()
print(a)运行结果：
{}
主要内建函数，使用方法如下代码所示：
names = ['Wangdachui', 'Niuyun', 'Linling', 'Tianqi']
salaries = [3000, 2000, 4500, 8000]
aInfo = dict(zip(names, salaries)) #dict()用于创建字典
print(aInfo)
print(len(aInfo)) #len()用于计算个数
print(hash('JXUST')) #hash()用于判断是否可变（是否可哈希）运行结果：
{'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000}
4
3915767897599782932
主要方法，使用方法如下代码所示：
1.输出键与值：
aInfo = {'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000}
print(aInfo.keys(), type(aInfo.keys()))
print(aInfo.values())运行结果：
dict_keys(['Wangdachui', 'Niuyun', 'Linling', 'Tianqi'])
dict_values([3000, 2000, 4500, 8000])
2.输出键值一一对应：
aInfo = {'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500, 'Tianqi': 8000}
for k, v in aInfo.items():
print(k, v)运行结果：
Wangdachui 3000
Niuyun 2000
Linling 4500
Tianqi 8000
3.更新字典:
aInfo = {'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500}
print(aInfo)
bInfo = {'Wangdachui': 4000, 'Niuyun': 9999, 'Wangzi': 6000}
aInfo.update(bInfo)
print(aInfo)运行结果：
{'Wangdachui': 3000, 'Niuyun': 2000, 'Linling': 4500}
{'Wangdachui': 4000, 'Niuyun': 9999, 'Linling': 4500, 'Wangzi': 6000}
字典的两种常见使用场景：
1.JSON格式
import json
x = {"name": "Niuyun", "address": {"city": "Beijing", "street": "Chaoyang Road"}}
json_str = json.dumps(x) #编码
print(json_str)
print(x['address']['street'])
print(json.loads(json_str)) #解码运行结果：
{"name": "Niuyun", "address": {"city": "Beijing", "street": "Chaoyang Road"}}
Chaoyang Road
{'name': 'Niuyun', 'address': {'city': 'Beijing', 'street': 'Chaoyang Road'}}
注：还可对JSON文件进行操作，在此不做展示
2.搜索引擎关键词查询
import requests
kw = {'q': 'Python dict'}
r = requests.get('http://cn.bing.com/search', params=kw)
print(r.text)可变长关键字参数（字典）,代码如下：
def func(args1, *argst, **argsd):
print(args1)
print(argst)
print(argsd)
func('Hello,', 'a', 'b', 'c', a1=1, a2=2, a3=3)运行结果如下所示：
Hello,
('a', 'b', 'c')
{'a1': 1, 'a2': 2, 'a3': 3}
注：要与元组的可变长位置参数区分开来
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
