入门大数据---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基础教程

系列传送门