Python

一、对象

• 一切皆对象，可以是变量，函数或类
• 每个文件都是一个模块

# 定义变量
str_1 = "星德川"

# 定义函数
def test_1():
    print("1")

# 定义类
class tests(object):
    def test_2(self):
        print("2")

# a是变量str_1的对象
a = str_1
print(a)

# b是函数test_1的对象
b = test_1
print(b())

# c是tests类的对象
c = tests
print(c().test_2())

二、变量

• 全局变量：直到程序结束后释放
• 局部变量：函数内部定义时默认局部变量

1、数据类型（常用）

数据名称	数据类型
str	字符串
byte	字节串
int	整型
floot	浮点型
bool	布尔型

2、定义变量

Python定义变量：变量名 = "变量值"

Java定义变量：返回模块的属性列表。

3、其中比较两个对象是否相等，需要如下几个条件都满足：

（1）内容一致

（2）类型一致，查看数据类型使用的关键字 type

（3）内存地址一致，查看内存地址关键词 id

4、定义不分配，使用时分配，使用完释放

5、判断字符串的关键字：

（1）==：比较两个对象的内容以及类型是否一致 ​ （2）is：判断两个变量是否引用同一对象 ​ （3）in：判断两个对象中一个对象是否包含另外一个对象

str_1 = "星德川"
str_2 = "星德川"
str_3 = "星德川家康"
int_1 = 21
float_1 = 2001.04
bool_1 = True

# 输出 str_1 和 str_2 内存地址
print(id(str_1))
print(id(str_2))
# 输出 str_1、int_1、float_1、bool_1类型
print(type(str_1))
print(type(int_1))
print(type(float_1))
print(type(bool_1))
# 判断 str_1 和 str_2 内容以及类型是否一致
print(str_1 == str_2)
# 判断 str_1 和 str_2 是否引用同一对象
print(str_1 is str_2)
# 判断 str_2 是否包含在 str_3
print(str_2 in str_3)

三、字符串

1、使用 dir() 方法返回参数的属性、方法列表

str_1 = "hello world"

print(dir(str_1))

• dir() 方法不带参数返回当前范围内的变量、方法和定义的类型列表；带参数返回参数的属性、方法列表
• 如果参数包含方法 dir()，该方法将被调用。如果参数不包含 dir()，该方法将最大限度地收集参数信息

2、对字符串方法的使用

str_1 = "hello world"
# 小写转大写
str_2 = str_1.upper()

print(str_2)
# 大写转小写
print(str_2.lower())
# 判断是否为大写
print(str_2.isupper())
# 判断是否为小写
print(str_1.islower())
# 所有is开头的关键字都是判断，成立结果为True，如果不成立为False

# startswith()判断字符串以什么开头
print(str_1.startswith("h"))
# endswith()判断字符串以什么结束
print(str_1.endswith("e"))
# len()获取字符串的长度
print(len(str_1))
# replace()方法替换字符串的内容
print(str_1.replace("world", "Python"))

str_3 = "Python,Java,C"
str_list = str_3.split(',')
# 字符串转列表，split()对指定分隔符对字符串进行切片
print(str_list)

str_list = "|".join(list_str)
# 列表转字符串，使用指定连接符使用join()连接列表
print(str_list)

str_4 = "123"
# isdigit()判断是否只为数字，是则输出为整形
if str_4.isdigit():
    print(int(str_4))
print(str_1.isdigit())

print(str_1.index("w"))
# index()返回指定值的出现位置，无则抛出异常
print(str_1.count("w"))
# count()检索某字符出现的次数

str_5 = "  this  "
# strip()只能删除开头或是结尾字符，不能删除中间部分字符
print(str_5.strip())

str_6 = "阿巴阿巴阿巴"
list_1 = []

for index, item in enumerate(str_6):
    # enumerate()遍历的数据对象组合为一个索引序列
    if index > 3:
        list_1.append(item)
        # append()在列表末尾添加新的对象
print(list_1)

四、列表

1、使用 dir() 方法返回参数的属性、方法列表

list_1 = ["Python", "Java"]

print(dir(list_1))

2、特点

（1）可存放多个值

（2）列表是有序的，按照从左到右的顺序定义列表元素，从0开始顺序访问

（4）列表也是可变化的，可根据列表索引修改列表的值

3、对列表方法的使用

list_1 = ["Python", "Java"]
list_1.append("C")
# append()在列表末尾添加新的对象
print(list_1)

list_1.insert(0, "C++")
# insert()在列表中添加对象，根据索引添加对象
print(list_1)

list_2 = [1, 2, 3, 4]
list_1.extend(list_2)
# extend()两个列表合并
print(list_1)

list_1.remove("Python")
# remove()可以指定删除对象
print(list_1)

print(list_1.pop())
# pop()删除列表中的最后一位对象且返回该元素的值
print(list_1)

list_1.reverse()
# reverse()反转
print(list_1)
# index()获取到对象的索引信息
print(list_1.index("C++"))

list_3 = [1, 2]
list_4 = ["Python", "Java"]
print(dict(zip(list_3, list_4)))
'''
zip()将可迭代对象作为参数，将对象中对应元素打包成元组，然后返回由元组组成的对象
dict()创建字典
'''

list_5 = [1, 89, 90, 45, 109, 33, 99, 22, 4, 1109]
# 切片序列；从左到右0开始，从右到左-1开始
print(list_5[0:4])
print(list_5[-1])

list_5.sort()
print(list_5)
# sort()列表的对象根据ascll编码排序

lists = [
    [2, 3, 5],
    ["Go", "Python", [5, 8, 9, ["Go"]]]
]
# 根据索引获取数值
print("获取第一个Go语言", lists[1][0])
print("获取第二个Go语言", lists[1][2][3][0])

五、元组

1、元组和列表区别

（1）元组是不可变（不能修改、不可增加、不可删除）

（2）列表是可变（可增加、可把已有对象删除）

tuple_1 = ("Go", "Python", "Net")

print(tuple_1.count("Go"))
# count()统计指定数值出现次数
print(tuple_1.index("Net"))
# index()检测字符串是否包含子字符串，如果指定开始和结束范围，则检查是否包含在指定范围内，包含则返回索引值，否则抛出异常

tuple_2 = ("Go",)
# 元组只有一个对象时记加“,”
print(type(tuple_2))

2、多线程使用元组

（1）元组只有一个对象时记加”，“

（2）multiprocessing 支持使用类似于线程模块的 API 生成进程。multiprocessing 提供本地和远程并发，通过子进程而不是线程有效地避开全局解释器锁。因此，multiprocessing 允许程序员充分利用多个处理器；它可以在Unix和Windows上运行。

import multiprocessing
from multiprocessing import Process


def func(name):
    print(multiprocessing.current_process().pid, name)


if __name__ == '__main__':
    p = Process(target=func, args=('星德川',))
    p.start()

六、字典

1、使用 dir() 方法返回参数的属性、方法列表

dict_1 = {"name": "星德川"}
'''
字典是无序的
字典以 key:value 形式储存
'''
print(dir(dict_1))

2、对字典方法的使用

dict_1 = {"name": "星德川", "address": "xi'an"}
# copy()复制字典
dict_2 = dict_1.copy()

print(dict_2)
# 根据key获取具体的value的值的内容
print(dict_2['address'])
# 获取所有的key值
for key in dict_2.keys():
    print(key)
# 获取所有的value的值
for value in dict_2.values():
    print(value)

dict_3 = {"work": "tester"}
# update()数据更新
dict_2.update(dict_3)
print(dict_2)
# 对字典进行循环
for key, value in dict_2.items():
    print(key, ':', value)

'''
sorted()对所有对象排序操作
items()返回可遍历的(键, 值) 元组数组
lambda 参数:表达式（匿名函数）
[0]使用key值进行排序
[1]使用value值进行排序
'''
print(dict(sorted(dict_2.items(), key=lambda item: item[0])))
print(dict(sorted(dict_2.items(), key=lambda item: item[1])))

# pop删除 并且返回删除的元素
print(dict_2.pop("address"))
print(dict_2)

dict_2.clear()
# clear清空
print(dict_2)

七、输入输出

• format() 方法格式化指定值，并将其插入字符串的占位符内

name = input("请输入你的名字\n")
age = int(input("请输入你的年龄\n"))
salary = float(input("请输入你的薪资\n"))
isBoy = bool(input("你是男还是女\n"))
# 输入的均为字符型，后转换

# 命名索引 {price}
print('我的姓名：{name},我的年龄：{age}，我的薪资：{salary},我的性别:{isBoy}'
      .format(name=name, age=age, salary=salary, isBoy=isBoy))

# 编号索引{0}
print('my name is {0},and my sge is {1},and my salary is {2},and my sex is {3}'
      .format(name, age, salary, isBoy))

# 占位符 %s
print('我的姓名：%s,我的年龄：%s，我的薪资：%s，我的性别：%s'
      % (name, age, salary, isBoy))

# 查看数据类型
print(type(name))
print(type(age))
print(type(salary))
print(type(isBoy))

八、编码解码

str_1 = "星德川"

byte_str = str_1.encode("utf-8")
# encode()将str数据类型转为bytes数据类型
print(byte_str)

str_byte = byte_str.decode("utf-8")
# decode()将bytes数据类型转为str数据类型
print(str_byte)

九、控制流

str_1 = "欢迎回来"
print('获取字符串的长度:', len(str_1))

# range()返回一个可迭代对象
for item in range(len(str_1)):
    print(item)

# 使用 for 循环输出对象
for item in str_1:
    print(item)

# enumerate()循环输出字符串内容且输出每个对象索引
for index, item in enumerate(str_1):
    print(index, ':', item)

 

 

 

 

 

 

 

 

 

 

 

 

 

 

、注释

• 单行注释使用 #
• 多行注释使用 """ """

1、三引号定义变量本身是多行。

2、单引号与双引号是等价的，建议使用双引号。

3、单引号和双引号可以相互包含。

# 定义多行变量
str_1 = """python
java
"""
print(str_1)

'''
单双引号等价
单引号包含双引号
'''
str_2 = '"hello"'
print(str_2)

# 双引号包含单引号
str_3 = "'Python'"
print(str_3)