大数据基础---Python基础
前言
由于AI的发展，包括Python集成了很多计算库，所以淡入了人们的视野，成为一个极力追捧的语言。
首先概括下Python中文含义是蟒蛇，它是一个胶水语言和一个脚本语言，胶水的意思是能和多种语言集成，脚本的意思是没有强制类型，直接解释执行，和PHP类似。
下面是对Python的一些基础语法介绍。
安装教程这里就不说了，大家自行百度，小编这里用的是PyCharm开发。
现在主流的就是Python3.X，所以下面讲解的3.X。2.X不建议学了，因为慢慢就被取代了。
下面直接贴代码和运行结果：
第一部分：【基本】
# 打印hello world
print("hello world")
'''
字符类型
'''
# 整形
print("---整形---")
a = 10
print(a)
# 浮点型
print("---浮点型---")
b = 10.1
print(b)
# 字符串
print("---字符串---")
c = "hello string"
print(c)
# 布尔值
print("---布尔值---")
d = True
print(d)
# 空值
print("---空值---")
e = None
d = 12
print("d的类型是", type(d))
# 打印关键字
print("---打印关键字---")
import keyword
print(keyword.kwlist)
# 格式化输出
print("---格式化输出---")
'''
%s代表字符串，%d代表int类型，%f代表浮点型
'''
print("我叫%s,我的年龄是%d，我今年挣了%f￥" % ("一明", 18, 0.01))
# 打印输入语句
# print("请输入内容：")
# str1=input()
# print(str1)
# 赋值运算符
print("---赋值运算符---")
'''
*=
%=
+=
-=
PS：python没有i++,--i等操作
'''
a += 1
print(a)
# 比较关系
'''
==
!=
>
<
>=
<=
'''
# 逻辑判断
print("---逻辑判断---")
if a >= 18:
print("我是成年人了")
else:
print("我还未成年")
if d:
print("对，你说的都对")
# print("给你一次成人的机会：")
# a = input()
# a = int(a)
# if a >= 18:
# print("我是成年人了")
# else:
# print("我还未成年")
# 嵌套循环
print("---嵌套循环---")
if a >= 18:
if a < 30:
print("我还是青少年")
else:
print("我已经是而立之年")
else:
print("我还未成年")
# while循环
print("---while循环---")
i = 0
j = 0
while i < 6:
j = 0
while (j <= i):
print("*", end=" ")
j += 1
print("\n")
i += 1
# for循环
print("---for循环---")
'''
for 变量 in 一个列表或者一个字符串
'''
for i in "hello":
print(i)
# break和continue可以提前退出循环
print("---break和continue可以提前退出循环---")
i = 0
while i < 10:
print(i, end=" ")
i += 1
if i == 6:
break
# 下标
print("---下标---")
name = "YiMing"
print(name[0])
print(name[-1]) # 拿倒数第一个元素
# 切片
'''
切片采用的是左闭右开的类型，及从"起始"位开始到"结束"位的前一位结束（不包括结束位本身）
'''
print("---切片---")
str2 = "abcdef"
print(str2[1:5]) # 打印下标1至下标4
print(str2[1:]) # 打印下标1至结尾
print(str2[:5]) # 打印下标0至下标4
print(str2[1:-1]) # 打印下标1至到数第二位
# 字符串常见操作
print("--字符串常见操作---")
str3 = " Hello YiMing,What are you doing?"
print(str3.count("Hello")) # 计算单词次数
print(len(str3)) # 计算字符串长度
print(str3.find("q", 0, len(str3))) # 查找指定字符出现的位置 find（字符，开始位置，结束位置）
print(str3.index("H", 0, len(str3))) # 这个也是查询位置，和上面的区别是，find查询不出来，返回-1，indx查找不到不返回任何值
list2 = str3.split(" ") # 分割字符串
for s in list2:
print(s)
str3 = str3.replace("Hello", "Hi", str3.count("Hello")) # 替换字符串。 还有第三个参数，是用来指定替换多少个的
print(str3)
str3 = str3.title()
print(str3) # 将首字母全部转换为大写
str4 = "gogogo"
str4 = str4.capitalize() # 将字符串首字母转换为大写
print(str4)
print(str4.startswith("go")) # 检查首字母是否以go开头 （区分大小写）
print(str4.endswith("go")) # 检查首字母是否以go结束
print(str4.lower()) # 将所有字母转换为小写
print(str4.upper()) # 将所有字母转换为大写
str4 = str4.ljust(40)
print(str4.ljust(50)) # 左对单词长度为40。 不足的在单词后面用空字符补齐
print("长度", len(str4))
print(str4.rjust(50)) # 右对齐长度为40，不足的在单词前面用空字符补齐
print(str4.center(50)) # 居中对齐，不足的在两边补齐
print("删除左边空白", str4.lstrip())
print("删除右边空白", str4.rstrip())
str5 = "What are you doing"
print("从左边开始查找：", str5.find("e", 0, len(str5))) # 这个是从左边开始查找单词位置
print("从右边开始查找:", str5.rfind("e", 0, len(str5))) # 这个从右边开始查找，但是和左边开始查找结果一样
str6 = "Hi\n YiMing"
str7 = str6.splitlines()
for s7 in str7:
print(s7)
str8 = "我是 word"
print(str8.isalpha()) # 判断是否全是字母
str9 = "12"
print(str9.isdigit()) # 判断是否全是数字
print("所有字符都是字母或者数字:", str9.isalnum()) # 所有字符都是字母或者数字则返回True
print(str8.isspace()) # str8中只包含空格，则返回Ture，否则返回False
print(str8.join(str9)) # 将str8中的每个元素插入到str9里面
# 列表
print("---列表---")
list1 = ["张三", 11, "李四", "赵六"]
print(len(list1))
print(list1[0])
list2 = ["繁星"]
list1.extend(list2) # 另一集合元素添加到list1中
print(len(list1))
list1[0] = "一明" # 替换下标0的张三为一明
if "张三" in list1: # 使用in ， not in判断某元素是否存在
print("存在")
else:
print("不存在")
del list1[0] # 根据下标删除元素
print(list1[0])
list1.remove(11) # 删除指定元素
print(list1[0])
print("打印最后一个元素", list1[len(list1) - 1]) # 打印最后一个元素
print(list1.pop()) # 移除最后一个元素
print("打印最后一个元素", list1[len(list1) - 1]) # 打印最后一个元素
list3 = [1, 4, 5, 3]
list3.sort() # 从小到大排序
print("从小到大排序", list3)
list3.reverse() # 从大到小排序
print("从大到小排序", list3)
# 元组
print("---元组---")
'''
元组和列表类似，不同之处 元组不能修改 。元组用(小括号)，列表用[中括号]
'''
tup1 = (11, 2, 43, 5)
print(tup1[0])
list4 = [88, 99]
tup2 = (11, list4)
print(tup2[1])
list4.append(44)
print(tup2[1])
# 字典
print("---字典---")
'''
字典用{花括号}表示
'''
dic1 = {"name": "张三", "age": 33}
print(dic1["name"])
print(dic1.get("name")) # 如果不确定是否存在，可以用get获取避免报错
print(dic1.get("name1", "无名氏")) # 如果不存在的话，返回默认值 "无名氏"
dic1["name"] = "李四" # 修改name
print(dic1["name"])
dic1["gender"] = 1 # 增加元素
print(dic1["gender"])
# 一些常见操作
print("字典长度为:", len(dic1))
print("字典的所有值为:", dic1.values())
# 遍历字典
print("遍历所有key")
for item in dic1.keys():
print(item)
print("遍历所有value")
for item in dic1.values():
print(item)
print("遍历所有key，value")
for key, value in dic1.items():
print("key=", key, "value=", value)
print("遍历所有item")
for item in dic1.items():
print(item)
# 可变类型，不可变类型
print("---可变类型，不可变类型---")
'''
可变类型：值可以改变
可变类型有：list，dict
不可变类型：值不可以改变
我们看到有一些字符串，通过某些方法打印的值改变了，其实它是产生了一个新的变量，并把值赋值给新变量。
不可变类型有：string，long，bool，tuple
'''
# Python的函数
print("---Python的函数---")
def printInfo():
print("人生苦短，我用Python")
printInfo()
def addNum(a, b): # 带参数函数
c = a + b
print(c)
addNum(1, 2)
# 参数默认值设置
def fun1(a, b=10): # 如果b没有设置参数，则使用默认值10进行运算
print(a + b)
fun1(1)
fun1(1, 3)
# 设置不定长参数
print("设置不定长参数:")
def fun2(a, *b, **c): # *接收的是不定长参数，**接收的是 key=value 形式参数
print(a)
print(b)
print(c)
fun2(1, 2, 3, 4, age1=11, age2=22)
print("华丽分割线————")
tup3 = (6, 7, 8)
dic2 = {"num1": 1, "num2": 2}
fun2(1, *tup3, **dic2)
# 函数返回值
print("返回值函数")
def fun3(x, y):
return x * y
result = fun3(4, 7)
print(result)
# 利用元组返回多个值
def fun4(x, y):
addResult = x + y
divResult = x // y # 整除
return addResult, divResult
addRec, divRec = fun4(8, 5)
print("addRec:", addRec)
print("divRec:", divRec)
# 方法内部修改全局变量方法 （在变量前面声明一个global）
'''
在函数中修改全局变量：
如果变量是可变类型，则可以随意修改。
如果是不可变类型，则不能修改指向。除非加上global。
下面是针对不可变类型int的演示。
'''
global1 = 11
def ff():
global global1
global1 = 22 # 声明一个glboal，在外部使用才会看到修改。
ff()
print("全局变量的值为:", global1)
print("递归函数")
diGuiResult = 0
def diGuiFun(a):
if (a == 1):
return 1
return a * diGuiFun(a - 1)
print(diGuiFun(4))
# 匿名函数
sum = lambda arg1, arg2: arg1 + arg2
print(sum(1, 2))
stus = [{"name": "三七", "age": 33}, {"name": "二六", "age": 66}, {"name": "一明", "age": 44}]
print("使用匿名函数针对age进行排序")
stus.sort(key=lambda x: x["age"])
print(stus)
print("使用匿名函数针对key进行排序")
stus.sort(key=lambda x: x["name"])
print(stus)
第一部分运行结果:
F:\Code\Python\FirstDay\venv\Scripts\python.exe F:/Code/Python/FirstDay/vip/shuai7boy/python/test.py
hello world
---整形---
10
---浮点型---
10.1
---字符串---
hello string
---布尔值---
True
---空值---
d的类型是 <class 'int'>
---打印关键字---
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
---格式化输出---
我叫一明,我的年龄是18，我今年挣了0.010000￥
---赋值运算符---
11
---逻辑判断---
我还未成年
对，你说的都对
---嵌套循环---
我还未成年
---while循环---
*
* *
* * *
* * * *
* * * * *
* * * * * *
---for循环---
h
e
l
l
o
---break和continue可以提前退出循环---
0 1 2 3 4 5 ---下标---
Y
g
---切片---
bcde
bcdef
abcde
bcde
--字符串常见操作---
1
34
-1
2
Hello
YiMing,What
are
you
doing?
Hi YiMing,What are you doing?
Hi Yiming,What Are You Doing?
Gogogo
False
True
gogogo
GOGOGO
Gogogo
长度 40
Gogogo
Gogogo
删除左边空白 Gogogo
删除右边空白 Gogogo
从左边开始查找： 7
从右边开始查找: 7
Hi
YiMing
False
True
所有字符都是字母或者数字: True
False
1我是 word2
---列表---
4
张三
5
不存在
11
李四
打印最后一个元素 繁星
繁星
打印最后一个元素 赵六
从小到大排序 [1, 3, 4, 5]
从大到小排序 [5, 4, 3, 1]
---元组---
11
[88, 99]
[88, 99, 44]
---字典---
张三
张三
无名氏
李四
1
字典长度为: 3
字典的所有值为: dict_values(['李四', 33, 1])
遍历所有key
name
age
gender
遍历所有value
李四
33
1
遍历所有key，value
key= name value= 李四
key= age value= 33
key= gender value= 1
遍历所有item
('name', '李四')
('age', 33)
('gender', 1)
---可变类型，不可变类型---
---Python的函数---
人生苦短，我用Python
3
11
4
设置不定长参数:
1
(2, 3, 4)
{'age1': 11, 'age2': 22}
华丽分割线————
1
(6, 7, 8)
{'num1': 1, 'num2': 2}
返回值函数
28
addRec: 13
divRec: 1
全局变量的值为: 22
递归函数
24
3
使用匿名函数针对age进行排序
[{'name': '三七', 'age': 33}, {'name': '一明', 'age': 44}, {'name': '二六', 'age': 66}]
使用匿名函数针对key进行排序
[{'name': '一明', 'age': 44}, {'name': '三七', 'age': 33}, {'name': '二六', 'age': 66}]
Process finished with exit code 0
第二部分:【文件】
# Python文件操作
print("---Python文件操作---")
"""
文件操作规则:
r是只读模式，这是默认模式
w会将文件内容覆盖。如果文件不存在，则创建。
a追加文件内容。如果文件不存在，则创建。
rb以二进制格式打开一个文件，只读。这是默认模式
wb以二进制格式打开一个文件，将文件内容覆盖。如果文件不存在，则创建
ab以二进制格式打开一个文件，将内容追加到文件，如果文件不存在，则创建。
r+ 打开一个文件用于读写，文件指针将放在文件的开头。
w+ 打开一个文件用于读写，如果文件以存在，则覆盖。如果不存在，则创建。
a+ 打开一个文件用于读写，如果文件以存在，则追加内容。如果不存在，则创建。
rb+ 以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头
wb+ 以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
ab+ 以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。
"""
print("写数据")
f = open(r"F:\Code\Python\FirstDay\data\1.txt", "w")
f.write("hello world")
f.close()
print("写入成功")
print("读数据")
f2 = open(r"F:\Code\Python\FirstDay\data\1.txt", "r")
print(f2.read(1)) # read括号里面可以指定读取的长度,如果不指定则读取所有数据
f2.close()
# 按照行的方式把文件一行一行读取
f3 = open(r"F:\Code\Python\FirstDay\data\2.txt", "r")
r3 = f3.readlines()
print(type(r3))
for item in r3:
print(item)
f3.close()
# 文件定位读写
f4 = open(r"F:\Code\Python\FirstDay\data\2.txt", "r")
r4 = f4.read(3)
print(f4.tell())
f4.seek(5, 0) # 重新设置自定义位置。 第一个参数是偏移量。第二个参数一共有三个值，0代表开头，1代表当前位置，2代表结尾
print(f4.tell())
print(f4.read())
f4.close()
# 文件相关操作
import os # 文件操作模块
# os.rename(r"name1.txt", r"name2.txt") 修改文件名称
print(os.name) # 判断正在使用的平台，window平台打印nt，linux平台打印posix
print("当前文件路径为:", os.getcwd())
print("当前工作目录下所有文件为:", os.listdir())
# os.remove("name2.txt") #删除指定文件
# os.rmdir("../python") #删除指定目录
# os.mkdir("mydir") #创建目录
# os.path.isfile("") #判断指定对象是否是文件，是的话返回True，否则返回False
# os.path.isdir("") # 判断指定对象是否是文件夹，是的话返回True，否则返回False
# os.path.exists("") # 判断指定对象是否存在
# os.system("echo hello world") #执行shell命令
# os.chdir("", "") # 改变目录到指定目录
# os.path.getsize("") #获得文件的大小
# os.path.abspath("name2.txt") #获得绝对路径
第二部分运行结果：
F:\Code\Python\FirstDay\venv\Scripts\python.exe F:/Code/Python/FirstDay/vip/shuai7boy/python/test2.py
---Python文件操作---
写数据
写入成功
读数据
h
<class 'list'>
hello world
What are you doing?
I am coding..
3
5
world
What are you doing?
I am coding..
nt
当前文件路径为: F:\Code\Python\FirstDay\vip\shuai7boy\python
当前工作目录下所有文件为: ['FirstPy.py', 'mydir', 'name2.txt', 'support.py', 'test.py', 'test2.py', 'test3.py', 'test4.py', 'test5.py', 'test6.py', 'tt1.py', '__init__.py', '__pycache__']
Process finished with exit code 0
第三部分:【类】
# 定义类
class Person:
def say(self):
print("我叫:", self.name, "，我今年:", self.age, "岁了。")
# 调用
ZhangSan = Person()
ZhangSan.name = "张三"
ZhangSan.age = 21
ZhangSan.say()
# 在定义类时，同时初始化对象
class Person2:
def __init__(self):
self.name = "李四"
self.age = 44
def say(self):
print("我叫:", self.name, "，我今年:", self.age, "岁了。")
LiSi = Person2() # 这样不赋值的话，就会使用默认的。
LiSi.say()
# 构建有参数的类
print("---构建有参数的类")
class Person3:
def __init__(self, name, age):
self.name = name
self.age = age
def say(self):
print("我叫:", self.name, "，我今年:", self.age, "岁了。")
ZhaoLiu = Person3("赵六", 66)
ZhaoLiu.say()
# 构建有初始化对象的类 __new__
print("---构建有初始化对象的类")
class Test1(object):
def __init__(self):
print("我是初始化后加工方法")
def __new__(cls, *args, **kwargs):
print("我是初始化方法")
return object.__new__(cls)
Test1() # 调用
# 删除类对象时会调用的方法 __del__
print("---删除类对象时会调用的方法")
class Test2(object):
def __init__(self):
print("我是初始化后加工方法")
def __new__(cls, *args, **kwargs):
print("我是初始化方法")
return object.__new__(cls)
def __del__(self):
print("我马上消失.")
t2 = Test2()
del t2 # 删除对象
# Python定义私有属性
'''
Python没有private专门修饰符来定义，它用了两个'_'代表私有属性，类也是，类名前面加上两个'_'代表私有的，否则就是公共的。
'''
__phone = 1 # 定义一个私有变量
# 继承
print("---继承---")
class QQ(object):
def __init__(self, password, qqNum):
self.__password = password
self.qqNum = qqNum
def getPassWord(self):
print("密码是:", self.__password)
class MyQQ(QQ):
def talk(self):
print("我的QQ是:", self.qqNum)
YiMingQQ = MyQQ(666, 10101001010101)
YiMingQQ.talk()
YiMingQQ.getPassWord()
# 重写
print("---重写---")
class PClass:
def say(self):
print("我是父类")
class ChildClass(PClass):
def say(self):
print("我是子类")
CP = ChildClass()
CP.say()
# 多态
print("---多态---")
'''
Python中多态属于"鸭子类型"
'''
# 类属性和实例属性
'''
上面主要涉及了实例属性。
类属性就是在类里面定义变量，由父类和子类共享。 当然私有变量不能被对象调用和共享的。
类属性相当于Java，C#的静态成员变量，只在内存中存在一份。
'''
print("类属性和实例属性")
class P1(object):
name = "无名氏"
__age = 0
p1 = P1()
print(p1.name)
print(P1.name) # 除了实例调用，类属性还可以直接调用
# print(p1._age) # 错误，私有属性是访问不到的
'''
如果需要在类外修改类属性，必须通过类对象去引用然后进行修改。如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。
'''
# 类方法和静态方法
'''
类方法使用@classmethod标识，静态方法使用@staticmethod标识
类方法需要定义参数，通常名称为：'cls'，静态方法无需定义额外参数
'''
print("---类方法和静态方法---")
#
class Earch(object):
__country = "China"
def getCountry(self):
return self.__country
@classmethod
def setCountry(cls, country):
cls.__country = country
earch = Earch()
Earch.setCountry("中国")
print(earch.getCountry())
# 静态方法可以直接类名.方法名调用，如下所示：
class Earch2(object):
__country = "China"
@staticmethod
def getCountry():
return Earch2.__country # 由于声明了静态方法，所以使用类直接调用返回即可。
@classmethod
def setCountry(cls, country):
cls.__country = country
Earch2.setCountry("日本")
print(Earch2.getCountry())
第三部分运行结果:
F:\Code\Python\FirstDay\venv\Scripts\python.exe F:/Code/Python/FirstDay/vip/shuai7boy/python/test3.py
我叫: 张三 ，我今年: 21 岁了。
我叫: 李四 ，我今年: 44 岁了。
---构建有参数的类
我叫: 赵六 ，我今年: 66 岁了。
---构建有初始化对象的类
我是初始化方法
我是初始化后加工方法
---删除类对象时会调用的方法
我是初始化方法
我是初始化后加工方法
我马上消失.
---继承---
我的QQ是: 10101001010101
密码是: 666
---重写---
我是子类
---多态---
类属性和实例属性
无名氏
无名氏
---类方法和静态方法---
中国
日本
Process finished with exit code 0
第四部分:【异常】
# coding:utf-8
# 捕获异常
print("---捕获异常---")
# 普通异常
try:
open("zzz.txt", "r")
except IOError as result: # 捕获并存储异常信息
print("读取文件发生异常:")
print(result)
# 带else的异常
print("带else的异常---")
try:
print("gogoogogo")
except IOError:
print("IO错误")
else:
print("没有发生异常，啦啦啦啦")
# 带finally异常
print("带finally异常---")
try:
open("zzz.txt", "r")
except IOError:
print("发生异常")
finally:
print("算了吧，我还是太年轻了")
'''
异常嵌套：
如果try嵌套，那么如果里面的try没有捕获到这个异常，那么外面的try会接收到这个异常，然后进行处理，如果外边的try依然没有捕获到，那么再进行传递。。。
如果一个异常是在一个函数中产生的，例如函数A---->函数B---->函数C,而异常是在函数C中产生的，那么如果函数C中没有对这个异常进行处理，那么这个异常会传递到函数B中，如果函数B有异常处理那么就会按照函数B的处理方式进行执行；如果函数B也没有异常处理，那么这个异常会继续传递，以此类推。。。如果所有的函数都没有处理，那么此时就会进行异常的默认处理，即通常见到的那样
注意观察上图中，当调用test3函数时，在test1函数内部产生了异常，此异常被传递到test3函数中完成了异常处理，而当异常处理完后，并没有返回到函数test1中进行执行，而是在函数test3中继续执行
'''
# 自定义引发异常
'''
使用raise进行引发。raise 对应的应是Error，Exception或它俩的子类
'''
# raise IOError("读写错误")
# raise Exception("又异常了？")
try:
print("")
except Exception:
pass # 如果这行代码出现了异常，那么后面的代码不会运行
第四部分运行结果:
F:\Code\Python\FirstDay\venv\Scripts\python.exe F:/Code/Python/FirstDay/vip/shuai7boy/python/test4.py
---捕获异常---
读取文件发生异常:
[Errno 2] No such file or directory: 'zzz.txt'
带else的异常---
gogoogogo
没有发生异常，啦啦啦啦
带finally异常---
发生异常
算了吧，我还是太年轻了
Process finished with exit code 0
第五部分:【模块】
# 模块
'''
Python中的模块就相当于Java中的包。导入方式也是import，比如我们前面使用的导入io。
'''
# 引入math模块
import math
print(math.sqrt(2))
# 引入模块中指定方法
'''
有时候我们仅仅想引用模块中某个方法，而不是整个模块，使用from ... import 即可
'''
from math import sqrt
sqrt(3)
第五部分运行结果:
F:\Code\Python\FirstDay\venv\Scripts\python.exe F:/Code/Python/FirstDay/vip/shuai7boy/python/test5.py
1.4142135623730951
Process finished with exit code 0
第六部分:【列表推导】
# 列表推导式
print("---列表推导式---")
'''
所谓列表推导式，就是循环创建列表
'''
list1 = [i for i in range(1, 10)]
print(list1)
list2 = [i for i in range(1, 10) if i % 2 == 0]
print(list2)
print("---列表，元组，字典，集合之间的对比---")
'''
list=[] 列表无序，元素可以重复
tuple=() 元组有先后顺序，有下标位，元素可以重复
dict={"key":value} 字典无序，key不可重复
set=set() 集合，无序，不可重复
'''
list3 = [1, 1, 3, 4]
print(list3)
list4 = set(list3)
print(list4)
tup1 = (4, 3, 1, 6)
print(tup1[0])
第六部分运行结果：
F:\Code\Python\FirstDay\venv\Scripts\python.exe F:/Code/Python/FirstDay/vip/shuai7boy/python/test6.py
---列表推导式---
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[2, 4, 6, 8]
---列表，元组，字典，集合之间的对比---
[1, 1, 3, 4]
{1, 3, 4}
4
Process finished with exit code 0
第七部分：【自定义模块】
tt1.py
def say(word):
print("一明说:", word)
tt2.py
import tt1
# 引入自定义包
'''
Python中每个文件都可以看作是一个包，使用import 文件名 或者 from 包名 import 方法名 引入。
注意引入的时候，需要将 所在类的包标记为Sources Root。 及右键Mark Directory As -> Sources Root。这样才会有智能提示。
这个也表示了此文件是源代码文件。
'''
tt1.say("你好，世界！")
第七部分运行结果:
F:\Code\Python\FirstDay\venv\Scripts\python.exe F:/Code/Python/FirstDay/vip/shuai7boy/python/tt2.py
一明说: 你好，世界！
Process finished with exit code 0
第八部分:【数据库】
# Python操作数据库
''''
Python操作数据库很方便，直接引入pymysql包即可。
操作语句都写在execute（）里面。
execute（）执行是获取影响行数，如果拿具体的SQL执行结果需要fetchall。
步骤1：链接数据库，定位数据库
conn=connect(服务器IP，用户名，密码，数据库，端口) 这部分可以直接查看源码得知
cur=conn.cursor() 定位数据库
步骤2：构建执行语句
count=cur.execute("") 语句可以包括增删改查 ,返回受影响的行数
步骤3: 获取执行结果
result cur.fetchall() 拿到全部执行结果
步骤4:提交修改，关闭链接
conn.commit()
cur.close()
conn.close()
'''
from pymysql import *
print("---Python操作数据库---")
# 构建数据库链接
conn = connect("localhost", "root", "123456", "test", 3306)
cur = conn.cursor()
# 更新操作
count1 = cur.execute("update grade1 set `name`='三张' where `name`='张三'")
print(count1) # 打印受影响的行数
# 查询操作
count2 = cur.execute("select *from grade1;")
# 获取执行结果（具体的数据）
result = cur.fetchall()
for rs in result: # 循环展示结果
print(rs)
# 插入操作
count3 = cur.execute(
"insert into grade1(`name`,object,grade) values(%s,%s,%d)" % ("'一明'", "'Computer'", 100)) # 注意双引号里面加个单引号
print(count3)
conn.commit() # 插入跟新语句注意commit
cur.close()
conn.close()
第八部分运行结果:
F:\Code\Python\FirstDay\venv\Scripts\python.exe F:/Code/Python/FirstDay/vip/shuai7boy/python/test7.py
---Python操作数据库---
3
('三张', 'English', 11)
('三张', 'Chinese', 12)
('三张', 'Math', 13)
('李四', 'English', 14)
('李四', 'Math', 15)
('赵六', 'Chinese', 16)
1
Process finished with exit code 0
第九部分:【科学计算】
numpy基本运算
import numpy as np
# numpy类型
print("---numpy类型---")
a = np.dtype(np.float_)
print(a)
# int8,int16,int32,int64分别用 i1 ,i2, i4 ,i8替代
b = np.dtype('i1')
print(b)
# 创建数组
print("---创建数组---")
c = np.array([[1, 2, 3], [4, 5, 6]], dtype=int)
print(c.shape) # 打印结构为2行3列
d = np.arange(24).reshape(2, 3, 4) # 创建一个三维数组。还可以创建二维 np.arange(6).reshape(2, 3)
print(d)
# 基本运算
'''
rand 生成均匀分布的伪随机数。分布在（0~1）之间。
randn 生成标准正态伪随机数。 均值是0，方差是1
'''
print("---基本运算---")
print("一维运算---")
e = np.random.random(6)
f = np.random.rand(6)
g = np.random.randn(6)
print(e)
print(f)
print(g)
print("二维运算---")
e2 = np.random.random((2, 3))
f2 = np.random.rand(2, 3)
g2 = np.random.randn(2, 3)
print(e2)
print(f2)
print(g2)
print(np.dot(2, 4)) # 矩阵乘法
n1 = np.ones((2, 5)) # 生成2行5列的矩阵，元素都为1
n2 = np.zeros((2, 5)) # 生成2行5列的矩阵，元素都为0
print("结果为：", n1)
print("结果为:", n2)
# 常见函数
print("---常见函数---")
'''
abs,fabs 计算整数，浮点数的绝对值。
sqrt
'''
print(np.abs(-12)) # 计算整数的绝对值
print("浮点绝对值:", np.fabs(-3.14)) # 计算浮点数的绝对值
print("平方根:", np.sqrt(9)) # 计算平方根
print("平方:", np.square(2)) # 计算各元素的平方
print(np.exp(9)) # 计算个元素e^
print("对数值:", np.log10(100)) # 求对数。 log,log10,log2,log1p分别为自然对数，底数为10的log，底数为2的log和log(1+x)
print("正负号为:", np.sign(-23)) # 计算正负号：1(正数)，0（零），-1(负数)
print("向上取整:", np.ceil(2.3)) # 计算大于小于该值的最小整数
print("向下取整:", np.floor(2.3)) # 计算最小整数，及小于等于该值的最小整数
print("数组和为:", np.sum([1, 2, 3])) # 对数组中全部或某轴向的元素和。
print("数组平均值为:", np.mean([1, 2, 3])) # 计算算术平均数
print("标准差：", np.std([1, 2, 3])) # 计算标准差。 标准差计算公式为： √((平均值-x1)+（平均值-x2）+（平均值-x3))/元素个数
print("方差:", np.var([1, 2, 3])) # 计算方差。 方差和标准差少一步，就是不开方。 ((平均值-x1)+（平均值-x2）+（平均值-x3))/元素个数
print("最小值:", np.min([1, 2, 3])) # 打印最小值
print("最大值:", np.max([1, 2, 3])) # 打印最大值
print("最小值索引:", np.argmin([1, 2, 3])) # 最小值索引
print("所有元素阶梯累计和:", np.cumsum([1, 2, 3])) # 计算所有元素阶梯累计和
print("所有元素阶梯累计积:", np.cumprod([2, 2, 3])) # 计算所有元素阶梯累计积
print("四舍五入:", np.rint(3.1415)) # 四舍五入到最近整数
print(np.modf([3, 45, 12, 0, 5, 11])) # 将数组以整数部分，小数部分两个独立的数组返回
print(np.isnan([float("NaN"), 23, 44])) # 判断是否为NaN。 NaN是非数字的一个特殊值，可以把number设置为NaN来指示此值不是数字。
print("cos：", np.cos(90)) # cos，cosh，sin，sinh，tan，tanh普通型或双曲型三角函数 ，前面加上ar就是反三角函数
print("数组相加:", np.add([1, 2, 3], [4, 5, 6])) # 将数组中对应的元素相加
print("数组相减:", np.subtract([1, 2, 3], [4, 5, 6])) # 从第一个数组减去第二个数组中的元素
print("数组相乘:", np.multiply([1, 2, 3], [4, 5, 6])) # 将第一个数组元素乘以第二个数组元素
print("数组相除:", np.divide([8, 15, 3], [4, 5, 6])) # 将两个数组相除
print("数组相除，并向下取整", np.floor_divide([8, 15, 3], [4, 5, 6])) # 数组相除，并向下取整
print("数组指数运算:", np.power([1, 2, 3], [2, 2, 3])) # 两个数组对应位置做指数运算
print("取模运算:", np.mod(3, 2)) # 取模运算
print("符号复制", np.copysign([1, 2, 3], [-4, 5, 6])) # 将第二个数组符号赋值到第一个数组中的值
print("比较数组:", np.greater_equal([1, 2, 3], [4, 2, 6])) # 进行数组比较
print("唯一元素计算:", np.unique([1, 1, 2, 3, 9, 4])) # 计算数组中的唯一元素，并返回有序结果
print("数组相交值:", np.intersect1d([1, 2, 3], [3, 6, 7])) # 计算两个数组的公共元素
print("数组的并集:", np.union1d([1, 2, 3], [3, 6, 7])) # 计算两个数组的并集
print("数组包含某元素:", np.in1d(3, [3, 6, 7])) # 前一个元素是否包含于后面的数组
print("集合差:", np.setdiff1d([1, 2, 3], [3, 6, 7])) # 集合的差，及元素在第一个数组中，不在第二个中
print("异或:", np.setxor1d([1, 2, 3], [3, 6, 7])) # 异或，及存在一个数组中，但不存在于两个数组中的元素
print("矩阵乘法:", np.dot([1, 2, 3], [3, 6, 7])) # 矩阵乘法
print("矩阵行列式:", np.linalg.det(np.array([[1, 1], [1, 2]]))) # 矩阵行列式。 求法：对角线想乘-对角线相乘
print("特征值和特征向量:", np.linalg.eig(np.array([[1, 2], [1, 2]]))) # 特征值就是运行的速度，特征向量就是运行的方向。
print("逆矩阵:", np.linalg.inv(np.array([[1, 1, 1], [0, 2, 5], [2, 5, -1]]))) # 求逆矩阵
numpy基本运算结果：
F:\Code\Python\FirstDay\venv\Scripts\python.exe F:/Code/Python/FirstDay/vip/shuai7boy/python/test8.py
---numpy类型---
float64
int8
---创建数组---
(2, 3)
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
---基本运算---
一维运算---
[0.86770359 0.56616857 0.31614419 0.38133187 0.72912149 0.3242815 ]
[0.51159366 0.16152977 0.02869309 0.57144147 0.61089012 0.49114884]
[ 0.29766702 0.23493723 0.14115526 -1.29261721 -0.57533482 -0.44860585]
二维运算---
[[0.86053384 0.33917939 0.20983055]
[0.95293759 0.10255904 0.01336376]]
[[0.77379715 0.9487771 0.31541077]
[0.14415509 0.16419332 0.88090558]]
[[-0.73064851 1.13257581 -0.7313222 ]
[-1.24625777 -0.09798101 1.2632825 ]]
8
结果为： [[1. 1. 1. 1. 1.]
[1. 1. 1. 1. 1.]]
结果为: [[0. 0. 0. 0. 0.]
[0. 0. 0. 0. 0.]]
---常见函数---
12
浮点绝对值: 3.14
平方根: 3.0
平方: 4
8103.083927575384
对数值: 2.0
正负号为: -1
向上取整: 3.0
向下取整: 2.0
数组和为: 6
数组平均值为: 2.0
标准差： 0.816496580927726
方差: 0.6666666666666666
最小值: 1
最大值: 3
最小值索引: 0
所有元素阶梯累计和: [1 3 6]
所有元素阶梯累计积: [ 2 4 12]
四舍五入: 3.0
(array([0., 0., 0., 0., 0., 0.]), array([ 3., 45., 12., 0., 5., 11.]))
[ True False False]
cos： -0.4480736161291701
数组相加: [5 7 9]
数组相减: [-3 -3 -3]
数组相乘: [ 4 10 18]
数组相除: [2. 3. 0.5]
数组相除，并向下取整 [2 3 0]
数组指数运算: [ 1 4 27]
取模运算: 1
符号复制 [-1. 2. 3.]
比较数组: [False True False]
唯一元素计算: [1 2 3 4 9]
数组相交值: [3]
数组的并集: [1 2 3 6 7]
数组包含某元素: [ True]
集合差: [1 2]
异或: [1 2 6 7]
矩阵乘法: 36
矩阵行列式: 1.0
特征值和特征向量: (array([0., 3.]), array([[-0.89442719, -0.70710678],
[ 0.4472136 , -0.70710678]]))
逆矩阵: [[ 1.28571429 -0.28571429 -0.14285714]
[-0.47619048 0.14285714 0.23809524]
[ 0.19047619 0.14285714 -0.0952381 ]]
Process finished with exit code 0
索引，切片和迭代
import numpy as np
# 索引，切片和迭代
a = np.arange(10) ** 3
print("a的值为:", a)
print("切片为:", a[0:3])
# 多维数组切片
b = np.arange(6).reshape(2, 3)
print("b的值为:", b)
print("切片为:", b[0:2, 1])
print(b[-1, :]) # 当少于轴的索引被提供时，缺失的索引被认为是整个切片
print(b[-1])
print(b[1, ...])
'''
秩为5的数组(即它有5个轴)，那么:x[1,2,…] 等同于 x[1,2,:,:,:],x[…,3] 等同于 x[:,:,:,:,3]，x[4,…,5,:] 等同 x[4,:,:,5,:].
'''
d = np.array([[1, 2, 3], [4, 5, 6]]) # 创建ndarry
print("d:", d)
print(d.ndim) # 轴的个数（秩）
print(d.shape) # 数组维度
print(d.size) # 元素个数，等于shape中元组元素的乘积
print(d.dtype) # 类型
e = np.array([[[[1, 2, 3], [4, 5, 6], [7, 8, 9]]], [[[11, 12, 13], [14, 15, 16], [17, 18, 19]]]])
print("ndim:", e.ndim)
print("shape:", e.shape)
print(e[1, ...]) #
f = np.arange(12).reshape(2, 3, 2)
print("f:", f[1, 1]) # 等价于f[1][1]
print("循环迭代：")
for i in f:
print(i)
# 如果要对每个数组中元素进行运算，请使用flat属性。flat用于将数组切分得到一个个元素。
for i in f.flat:
print(i)
print("---华丽分割线---")
b1 = np.mat([[1, 2, 3], [4, 5, 6]])
print(b1.flatten())
# 形状操作
a1 = np.arange(10).reshape(2, 5)
print(a1.ravel())
print(a1.resize(5, 2))
索引，切片和迭代运算结果:
F:\Code\Python\FirstDay\venv\Scripts\python.exe F:/Code/Python/FirstDay/vip/shuai7boy/python/test9.py
a的值为: [ 0 1 8 27 64 125 216 343 512 729]
切片为: [0 1 8]
b的值为: [[0 1 2]
[3 4 5]]
切片为: [1 4]
[3 4 5]
[3 4 5]
[3 4 5]
d: [[1 2 3]
[4 5 6]]
2
(2, 3)
6
int32
ndim: 4
shape: (2, 1, 3, 3)
[[[11 12 13]
[14 15 16]
[17 18 19]]]
f: [8 9]
循环迭代：
[[0 1]
[2 3]
[4 5]]
[[ 6 7]
[ 8 9]
[10 11]]
0
1
2
3
4
5
6
7
8
9
10
11
---华丽分割线---
[[1 2 3 4 5 6]]
[0 1 2 3 4 5 6 7 8 9]
None
Process finished with exit code 0
形状操作
import numpy as np
#形状操作
'''
ravel(), vstack(),hstack(),column_stack,row_stack, stack, split, hsplit, vsplit
'''
# 增加维度
a = np.arange(5)
a[:, np.newaxis]
a[np.newaxis, :]
np.tile([1, 2], 2)
# 合并
a = np.arange(10).reshape(2, 5)
print(a.ravel())
print(a.resize(5, 2))
b = np.arange(6).reshape(2, 3)
c = np.ones((2, 3))
d = np.hstack((b, c)) # hstack：horizontal stack 左右合并
e = np.vstack((b, c)) # vstack: vertical stack 上下合并
f = np.column_stack((b, c))
g = np.row_stack((b, c))
h = np.stack((b, c), axis=1) # 按行合并
i = np.stack((b, c), axis=0) # 按列合并
j = np.concatenate((b, c, c, b), axis=0) # 多个合并
# 分割
k = np.hsplit(i, 2)
l = np.vsplit(i, 2)
m = np.split(i, 2, axis=0)
n = np.split(i, 2, axis=1)
o = np.array_split(np.arange(10), 3) # 不等量分割
形状操作运算结果:
F:\Code\Python\FirstDay\venv\Scripts\python.exe F:/Code/Python/FirstDay/vip/shuai7boy/python/test10.py
[0 1 2 3 4 5 6 7 8 9]
None
Process finished with exit code 0
总结文档参考Python基础教程
本文来自博客园，作者：数据驱动，转载请注明原文链接：https://www.cnblogs.com/shun7man/p/12867375.html
