列表list

Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。
比如，列出班里所有同学的名字，就可以用一个list表示：

# -*- coding: utf-8 -*-

classmates = ['Michael', 'Bob', 'Tracy']
print(classmates)
# ['Michael', 'Bob', 'Tracy']

变量classmates就是一个list。用len()函数可以获得list元素的个数：

>>> len(classmates)
3

用索引来访问list中每一个位置的元素，记得索引是从0开始的：

>>> classmates[0]
'Michael'
>>> classmates[1]
'Bob'
>>> classmates[2]
'Tracy'
>>> classmates[3]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

当索引超出了范围时，Python会报一个IndexError错误，所以，要确保索引不要越界，记得最后一个元素的索引是len(classmates) - 1。
如果要取最后一个元素，除了计算索引位置外，还可以用-1做索引，直接获取最后一个元素：

>>> classmates[-1]
'Tracy'

也可以把元素插入到指定的位置，比如索引号为1的位置：

>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

要删除list末尾的元素，用pop()方法：

>>> classmates.pop()
'Adam'>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

要删除指定位置的元素，用pop(i)方法，其中i是索引位置：

>>> classmates.pop(1)
'Jack'>>> classmates
['Michael', 'Bob', 'Tracy']

要把某个元素替换成别的元素，可以直接赋值给对应的索引位置：

>>> classmates[1] = 'Sarah'>>> classmates
['Michael', 'Sarah', 'Tracy']

元组tuple

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改，比如同样是列出同学的名字：

>>> classmates = ('Michael', 'Bob', 'Tracy')

现在，classmates这个tuple不能变了，它也没有append()，insert()这样的方法。其他获取元素的方法和list是一样的，你可以正常地使用classmates[0]，classmates[-1]，但不能赋值成另外的元素。
不可变的tuple有什么意义？因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。
tuple的陷阱：当你定义一个tuple时，在定义的时候，tuple的元素就必须被确定下来，比如：

>>> t = (1, 2)
>>> t
(1, 2)

如果元组里面存在列表 则可以修改列表里的某一项

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'>>> t[2][1] = 'Y'>>> t
('a', 'b', ['X', 'Y'])

字典dict

Python内置了字典：dict的支持，dict全称dictionary，在其他语言中也称为map，使用键-值（key-value）存储，具有极快的查找速度。
举个例子，假设要根据同学的名字查找对应的成绩，如果用list实现，需要两个list：

>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> d['Michael']
95

由于一个key只能对应一个value，所以，多次对一个key放入value，后面的值会把前面的值冲掉：

>>> d['Jack'] = 90>>> d['Jack']
90>>> d['Jack'] = 88>>> d['Jack']
88

如果key不存在，dict就会报错：

>>> d['Thomas']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'Thomas'

要避免key不存在的错误，有两种办法，一是通过in判断key是否存在：

>>> 'Thomas' in d
False

二是通过dict提供的get()方法，如果key不存在，可以返回None，或者自己指定的value：

>>> d.get('Thomas')
>>> d.get('Thomas', -1)
-1

注意：返回None的时候Python的交互环境不显示结果。
要删除一个key，用pop(key)方法，对应的value也会从dict中删除：

>>> d.pop('Bob')
75>>> d
{'Michael': 95, 'Tracy': 85}

集合set

set和dict类似，也是一组key的集合，但不存储value。由于key不能重复，所以，在set中，没有重复的key。
要创建一个set，需要提供一个list作为输入集合：

>>> s = set([1, 2, 3])
>>> s
{1, 2, 3}

注意，传入的参数[1, 2, 3]是一个list，而显示的{1, 2, 3}只是告诉你这个set内部有1，2，3这3个元素，显示的顺序也不表示set是有序的。。
重复元素在set中自动被过滤：

>>> s = set([1, 1, 2, 2, 3, 3])
>>> s
{1, 2, 3}

通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

>>> s.add(4)
>>> s
{1, 2, 3, 4}
>>> s.add(4)
>>> s
{1, 2, 3, 4}

通过remove(key)方法可以删除元素：

>>> s.remove(4)
>>> s
{1, 2, 3}

set可以看成数学意义上的无序和无重复元素的集合，因此，两个set可以做数学意义上的交集、并集等操作：

>>> s1 = set([1, 2, 3])
>>> s2 = set([2, 3, 4])
>>> s1 & s2
{2, 3}
>>> s1 | s2
{1, 2, 3, 4}

set和dict的唯一区别仅在于没有存储对应的value，但是，set的原理和dict一样，所以，同样不可以放入可变对象，因为无法判断两个可变对象是否相等，也就无法保证set内部“不会有重复元素”。试试把list放入set，看看是否会报错。
上面我们讲了，str是不变对象，而list是可变对象。
对于可变对象，比如list，对list进行操作，list内部的内容是会变化的，比如：

>>> a = ['c', 'b', 'a']
>>> a.sort()
>>> a
['a', 'b', 'c']

而对于不可变对象，比如str，对str进行操作呢：

>>> a = 'abc'>>> a.replace('a', 'A')
'Abc'>>> a
'abc'

虽然字符串有个replace()方法，也确实变出了’Abc’，但变量a最后仍是’abc’，应该怎么理解呢？
我们先把代码改成下面这样：

>>> a = 'abc'>>> b = a.replace('a', 'A')
>>> b
'Abc'>>> a
'abc'

函数

内置函数

而max函数max()可以接收任意多个参数，并返回最大的那个：

>>> max(1, 2)
2
>>> max(2, 3, 1, -5)
3

数据类型转换

Python内置的常用函数还包括数据类型转换函数，比如int()函数可以把其他数据类型转换为整数：

>>> int('123')
123
>>> int(12.34)
12
>>> float('12.34')
12.34
>>> str(1.23)
'1.23'
>>> str(100)
'100'
>>> bool(1)
True
>>> bool('')
False

空函数

pass语句什么都不做，那有什么用？实际上pass可以用来作为占位符，比如现在还没想好怎么写函数的代码，就可以先放一个pass，让代码能运行起来。
pass还可以用在其他语句里，比如：

if age >= 18:
    pass

缺少了pass，代码运行就会有语法错误。

返回多个值

函数可以返回多个值吗？答案是肯定的。
比如在游戏中经常需要从一个点移动到另一个点，给出坐标、位移和角度，就可以计算出新的坐标：

import math

def move(x, y, step, angle=0):
    nx = x + step * math.cos(angle)
    ny = y - step * math.sin(angle)
    return nx, ny

位置参数

def power(x):
  return x * x

print(power(2)) 

默认参数

def power(x, n=2):
    	s = 1
    	while n > 0:
        n = n - 1
        s = s * x
    return s

这样，当我们调用power(5)时，相当于调用power(5, 2)：

>>> power(5)
25
>>> power(5, 2)
25

可变参数

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n * n
    return sum

print(calc(1, 2)) #5
print(calc()) #0

创建运行环境venv

每个应用可能需要各自拥有一套“独立”的Python运行环境。venv就是用来为一个应用创建一套“隔离”的Python运行环境。

python -m venv venv

执行

./venv/Scripts/activate

就进入到了虚拟环境

然后就可以安装一些比如request的依赖了

pip install requests

import requests
httpUrl = "https://pvp.qq.com/web201605/js/herolist.json"

# 请求这个网址
resList = requests.get(httpUrl)
jsonData = resList.json()

for index in range(len(jsonData)):
    if(jsonData[index].get('skin_name')):
        print(jsonData[index]['cname']+"，英雄皮肤有" +
              jsonData[index]['skin_name']+"\n")

# print(jsonData)

面向对象编程

class Student:
    def __init__(self, name, age, score):
        self.__name = name
        self.__age = age
        self.score = score

    def display(self):
        print(self.__name, self.__age, self.score)


s1 = Student("小红", 19, 90)
s1.display()
s2 = Student("小红", 19, 90)
print(s1._Student__age)
print(s1.score)

print(Student)
print(s1, s2)

需要注意的是，在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名。
有些时候，你会看到以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。
双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。不能直接访问__name是因为Python解释器对外把__name变量改成了_Student__name，所以，仍然可以通过_Student__name来访问__name变量：

继承

class Animal:
    typeName = "Animal"

    def __init__(self, color):
        self.color = color

    def get_color(self):
        return self.color

    def say(self):
        print("I'm an animal")


class Dog(Animal):
    typeName = "Dog"

    def __init__(self, color, name):
        super().__init__(color)
        self.name = name
        self.typeName = "DogDog"

    def say(self):
        print("I'm a dog")


dog = Dog("brown", "Bob")
# dog.say()
# dog.sayDoy()
# print(dog.get_color())

animal = Animal("black")
# animal.say()


def say_hello(dog):
    dog.say()


say_hello(animal)

# print(type(animal))
# print(type(dog))

print(isinstance(animal, Dog))
print(isinstance(dog, Dog))
print(isinstance(dog, Animal))

# 查看dog所有的属性和方法
print(dir(dog))

print(dog.typeName)
print(Animal.typeName)

判断一个变量是否是某个类型可以用isinstance()判断：

>>> isinstance(a, list)
True>>> isinstance(b, Animal)
True>>> isinstance(c, Dog)
True

正则

import re
s1 = r'110'
reg = r'\d\d\d'

def regTest(reg,string):
    if re.match(reg,string):
        print("正则匹配成功")
    else:
        print("正则匹配失败")

regTest(reg,s1)

切分字符串

import re
re.split(r'\s+', 'a b   c')
'''
['a', 'b', 'c']
'''

import re
s1 = "时间：2023-09-15 21:45"
result = re.split(r'[：\-\s:]', s1)
print(
    "年："+ result[1]+'\n'
    "月："+ result[2]+'\n'
    "日："+ result[3]+'\n'
    "时："+ result[4]+'\n'
    "分："+ result[5]+'\n'
)
"""
年：2023
月：09
日：15
时：21
分：45
"""