python之路

python基础

#输入 输出
print(100+200)
a=input()
print("a:",a)

#%
print("my number is %d\nmy favoriate star is %s"%(3,"Jeremy lin"))

list tuple

#list
classmate=["wade",'kobe',"james"]
# "" ''  相同
print(classmate)
print(classmate[0])
print(len(classmate))
print(classmate[-1])
classmate.append('fly')
print(classmate)
classmate.pop()
print(classmate)
classmate.insert(0,'irving')
print(classmate)
classmate.pop(1)
print(classmate)

tuple 不能改变

if else

下面展示一些 内联代码片。

与c++不同的地方：
1.  10<A<20 对号
2. if X: 
    elif Y:
    else: 

s=input('birth: ')
birth=int(s)
if birth<2000:
    print('<2000')
elif 2000<birth<2500:
    print("between 2000 and 2500")
else:
    print(">2000")

注意input()使用方式

循环

stars=('Luka','Morant','Young','Zion','Booker')
for people in stars:
    print (people)

#range(x) 自动生成0-x-1的整数序列
for x in range(5):
    print(x)
x=0
while x<4:
    x=x+1
    print(x)

dict （map）set

链接: .items().
链接: .keys().
key可以为元组
pandas groupby 秒解决
https://zhuanlan.zhihu.com/p/149126583

#dict c++Map
mp={'Linsanity':7,'Yi':'8','Wang':14}
print(mp['Yi'])
if 'Lin' in mp:
    print('Yep!')
else:
    print('No')

#set
s=set([1,2,3,3,4])
print(s)
s.add(5)
print(s)

函数

下面展示一些 内联代码片。

power(x,n=2)
power(5) ：默认参数没有时，按默认参数处理
power(5,3)：默认参数有时，按输入处理

#function
def power(x,n=2):
    s=1
    for i in range(n):
        s=s*x
    return s

print(power(5))
print(power(5,3))

可变参数 *s
多于参数组成tuple

关键字函数*s

多余参数组成dict

切片

链接: link.

python模块

os

链接: link.

playsound

播放MP3

from playsound import playsound
playsound(mp3文件的绝对路径)

numpy

生成数组

import numpy as np
x=np.array([1,2,3])
print(x)

多维数组   广播

import numpy as np
x=np.array([[1,2],[3,4]])#([[],])
x=x*10#广播
print(x)

多维数组  的访问

import numpy as np
x=np.array([51,55,14,19,0,4])
print(x[0],x[1],x[2])
print(x[x>15])

python面向对象

类和实例 继承

class star(object):        #默认继承 object
    def __init__(self,name,number): #相当于构造函数
        self.__name=name        # __表示私有变量 仅能内部访问 外部people.__name_
        self.__number=number
    def get_info(self):
        return [self.__name,self.__number]
    def set_info(self,name,number):
        self.__name=name
        self.__number=number
    def say(self):
        print('I am a star')

class superstar(star):
    pass   # 啥都没有就pass
class ledgendary(star):
    def say(self):
        print('I am a legendary')

people1=star('James',23) #new一个类的实例
print(people1.get_info())
people1.set_info('Luka',77)
print(people1.get_info())

people1.say()

people2=ledgendary('Jordan',23)
people2.say()

type() isinstance()

下面展示一些 内联代码片。

type():输出类型  ~~不能判断实例属于什么类~~可以！ 
isinstance()：输出是否为指定的类型 判断示例属于某类

print(type(abs))
print(type('s'))
print(type(people1))
print(type(people2))
print(isinstance(1,int))
print(isinstance(people1,legendary))

实例属性和类属性

class Student(object):
    count = 0     #类属性
    type='Stu'    #类属性

    def __init__(self, name):
        self.name = name
        Student.count+=1 #每new一个实例，类属性+1，注意类属性的访问形式
A=Student('xxf')
print(A.type)   #实例访问类属性
print(Student.type)   #类访问类属性
print(Student.count)

进程和线程

多线程实现参考 链接: link.

刷题技巧

Counter()

可以用于计数

counter1 = Counter([1, 2, 3, 1, 2, 1])  # 从列表创建 Counter
counter2 = Counter("hello")  # 从字符串创建 Counter
counter3 = Counter({'a': 2, 'b': 3, 'c': 1})  # 从字典创建 Counter
counter = Counter([1, 2, 3, 1, 2, 1])

print(counter[1])  # 输出 3，元素 1 出现了 3 次
print(counter[4])  # 输出 0，元素 4 没有出现过

counter[2] = 5  # 更新元素 2 的计数为 5
del counter[3]  # 删除元素 3 的计数

print(counter.most_common(2))  # 输出 [(2, 5), (1, 3)]，计数最多的前两个元素是 2 和 1

逻辑运算符

|| -> or
! - > not
&& -> and

回溯写法

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        path = []
        result = []
        def dfs(start):
            result.append(path[:])
            for i in range(start, len(nums)):
                path.append(nums[i])
                dfs(i+1)
                path.pop()
        dfs(0)
        return result

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        if not digits:
            return []
        table = {'2':'abc', '3':'def', '4':'ghi', '5':'jkl', '6':'mno', '7':'pqrs', '8':'tuv', '9':'wxyz'}
        path = ''
        res = []
        n = len(digits)
        def dfs(start: int):
            nonlocal path
            #在这个修订的版本中，我在 dfs 函数内部添加了 nonlocal path 这一行，
            #这样我们就可以在函数内部修改 path 了。对于每个字符 c，我先将它添加到 path，
            #然后进行递归调用，最后我再移除 path 的最后一个字符，以便于在下次循环中尝试下一个字符。
            if(start==n):
                res.append(path)
                return
            for c in table[digits[start]]:
                path += c 
                dfs(start+1)
                path = path[:-1] # python string 不可变 只能这样写 无pop
        dfs(0)        
        return res

[:]

result = [] #二维数组
result.append(path[:])
'''
n Python, path[:] is a way of making a copy of the list.
 This is also known as slicing. 
 When you use [:] without specifying any index, 
 it creates a new list that contains all elements of the original list
'''

切片介绍
在Python中，切片是一种操作序列类型（如列表、元组和字符串）的方式，用于获取序列的子集。切片的基本语法如下：

sequence[start:stop:step]
其中：

start：切片开始的索引，如果省略则默认为0。
stop：切片结束的索引（不包括此索引），如果省略则默认到序列的末尾。
step：步长，即取值的间隔，如果省略则默认为1。
例如，有一个列表nums = [0, 1, 2, 3, 4, 5]：

python
Copy code
nums[1:4] # [1, 2, 3]
nums[:3] # [0, 1, 2]
nums[3:] # [3, 4, 5]
nums[::2] # [0, 2, 4]
nums[::-1] # [5, 4, 3, 2, 1, 0] （反转序列）
需要注意的是，Python的索引是从0开始的，负索引表示从末尾开始计数，例如-1表示最后一个元素。

切片操作返回的是一个新的序列，不会修改原始序列。所以，你可以使用切片操作来复制整个序列（如nums[:]），这会返回原始序列的一个完整副本。

nums[:-1] 是指只去掉最后一个元素的nums

整除

mid = (l + r) // 2

stack 用[]来模拟

    def dailyTemperatures(self, temperatures: List[int]) -> List[int]:
        stack = []
        n = len(temperatures)
        result = [0] * n
        for i in range(n):
            while stack and temperatures[i] > temperatures[stack[-1]]:
                index = stack.pop()
                result[index] = i - index
            stack.append(i)
        return result