python基础

a
!

print(str1[:5] + '!!!!')
print(str1[:9] + '!!!!')

制表符  \t   ,换行符\n

\在行尾  续行符

\\  反斜杠、单引号 \'、双引号\‘’

end=''

input()

使用表达式

替换变量

title()：首字母大写的方式显示每个单词，即将每个单词的首字母都改为大写

rstrip() 删除字符串尾部空格，临时删除，永久删除则需要存入变量中；lstrip() 删除字符串开头空格；strip()：删除两边空格

find() 查找，返回改字符串下标，否则返回-1

index()，返回改字符串下标，没有报错

count()  返回所查字符串的个数

rfind(),  返回字符串最后一次出现的位置，如果没有匹配项则返回-1

rindex(), 返回子字符串 str 在字符串中最后出现的位置，如果没有匹配的字符串会报异常，你可以指定可选参数[beg:end]设置查找的区间

replace()  修改,  str.replace(old, new[, max])
old -- 将被替换的子字符串。
new -- 新字符串，用于替换old子字符串。
max -- 可选字符串, 替换不超过 max 次

split()    分割,通过指定分隔符对字符串进行切片,返回分割后的字符串列表

join(),将序列中的元素以指定的字符连接生成一个新的字符串,返回通过指定字符连接序列中元素后生成的新字符串

capitalize()将字符串的第一个字母变成大写,其他字母变小写

 ljust rjust ceter   字符串对齐,  语法 字符串序列.ljust(长度,填充字符)

判断

name_list = ['Tom', 'Lily', 'Rose', 'Tom', 'Ann']

append()

extend()

insert()

index()

count()

len()

in

not in

修改指定下标的数据

del

pop()

remove

clear

reverse

sort

列表中遍历

格式

copy（）

name_list1 = [['赵', '钱', '孙', '李'], ['周', '吴', '郑', '王'], ['冯', '陈', '褚', '卫']]
print(name_list1[2])
print(name_list1[2][1])

t1 = ('aa', 'bb', 'cc', 'dd')
t2 = ('aa', 'bb', ['cc', 'dd'])

index（）

按下标查找

不可修改，元组中包含有可修改类型数据，如列表，则列表中数据可修改

元组中的元素值是不允许删除的，但可以使用del语句来删除整个元组

格式

访问列表长度 即元组中数据的个数

dict1 = {'name': 'Tom', 'age': 20, 'gender': '男'}

写法（注意 如果key存在则修改 对应的值，如果不存在则新增）,字典序列[]=值

update

del()/del

clear()

字典序列[key]=值

key值查找

get()，字典序列.get(key,默认值)

keys()

values()

items()

遍历key

遍历value

遍历键值对

s1 = {'10', '20'}

s2 = {10, 20, 30, 30, 20}
print(s2) # {10, 20, 30}

s3 = set('wfewrgjiwr')
print(s3) # {'e', 'g', 'r', 'j', 'f', 'i', 'w'}

add()

update()

remove()

discard()

pop()

in

not in

指变量生效的范围，分为局部变量和全局变量

定义在函数体内的变量 只在函数体内生效
在函数体内部 临时保存数据 函数调用完成后 则销毁局部变量

函数体内外都能访问

global

//

%(返回出发的余数)

>>>3<=2
False
2>>>!=3
True
>>>1+1==2
True

>>>(1>2 and 3>2)
False
>>>1<2 and 3>2
True

>>>1>2 or 3>2
True

>>>not 1>2
True
>>>not 3>2
False

在指定序列中找到指定之，返回True，否则返回False

在指定序列中没找到指定之，返回True，否则返回False

>>>True or False and False
True
>>>not True or False and False
False
>>>not False or False and False
True

条件成立执行的表达是 if 条件 else 条件不成立执行的表达式

age = int(input('输入年龄'))
if age >= 18 :
     print("可以上网")
else:
     print("未成年")

money = int(input("1为有钱非1为无："))
seat = int(input("1为有座非1为无："))
if money == 1:
     print("上车")
if seat == 1:
     print("有空座")
else:
     print("无空座位")
else:
     print("不能坐车")

while 条件:
     条件成立重复执行的代码

breaker  推出整个循环

continue   当条件成立 退出当前一次循环，继续执行下一次循环

语法

for 临时变量 in 序列：
     重复执行的代码1
     重复执行的代码2

breaker 推出整个循环

continue 当条件成立 退出当前一次循环，继续执行下一次循环

def add_num(n1, n2):
     result1 = n1 + n2
     print(result1)
# add_num(10, 20)

def user_info(name, age=40, gender='男'):
     print(f'名字{name},年龄{age},性别{gender}')
# user_info('tom', 3, '男')
# user_info('rose', gender='女', age=20)

传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组，*args 返回元组

收集所有的关键字参数，返回的是一个字典，无论是包裹位置还是包裹关键字传递，都是一个组包的过程

def return_num():
     # return 1, 2 # 返回元组
     # return (10, 20)
     # return [100, 300]
     return {'name': 'python', 'age': 30}
result = return_num()
print(result)

def sum_numbers(num):
     if num ==1:
         return 1
     return num +sum_numbers(num-1)
sumresult = sum_numbers(3)
print(sumresult)

fn1 = lambda a, b: a + b
print(fn1(1, 2))

lambda 参数列表：表达式

无参数 fn = lambda: 100
一个参数 fn = lambda a: a
两个参数 fn = lambda a, b, c=100: a + b + c
可变参数 *args lambda *args:args 注：可变参数传入到lambda之后，返回值为元组

lambda表达式的参数可有可无，函数的参数在lambda表达式中完全适用
lambda表达式能接收任何数量的参数但只能返回一个表达式的值

print(abs(-7)) # 7

print(round(1.2)) # 1
print(round(1.6)) # 2

list1 = [1, 2, 3, 4, 5]
def func(x):
     return x ** 2
result = map(func, list1)
print(result) # <map object at 0x0000026D5F36C9C8>
print(list(result)) # [1, 4, 9, 16, 25]

# 计算list1序列中各个数字的累加值和
import functools
list1 = [1, 2, 3, 4, 5]
def func(a, b):
     return a + b
result = functools.reduce(func, list1)
print(result) # 15

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
def func(x):
     return x % 2 == 0

result = filter(func, list1)
print(result) # <filter object at 0x00000225167AC988>
print(list(result)) # [2, 4, 6, 8, 10]

name:文件名 可包括具体路径
mode：访问模式 只读 写入 追加

f = open('test.txt', 'w')

f = open('test.txt', 'r')

f = open('test2.txt', 'a')

#print(f.read())
# print(f.read(8))

f.write('rr')

文件对象.seek(偏移量，起始位置)
起始位置：0 文件开头 1当前位置 2 文件结尾
r: 改变文件指针位置，改变读取数据开始位置或文件指针放结尾（无法读取数据）
a: 改变文件指针位置,可以读取数据

class Car(object):
     def __init__(self, make, model, year):
         self.make = make
         self.model = model
         self.year = year
         self.odometer_reading = 0

     def get_descriptive_name(self):
          long_name = str(self.year) + ' ' + self.make + ' ' + self.model
          return long_name.title()

     def read_odometer(self):
          print('This car has ' + str(self.odometer_reading) + ' miles on it')

     def update_odometer(self, mileage):
         if mileage >= self.odometer_reading:
             self.odometer_reading = mileage
         else:
              print("You can't roll back an odometer!")

     def increment_odometer(self, miles):
          self.odometer_reading += miles

要满足标识符命名规则

不去继承自己书写的类，默认级成所有类的顶级类 object ；其他类都叫派生类

引号中，是类的说明，在类的第一行，通过.__doc__查看

odometer_reading是类变量，它的值能在这个类里面的所有实例间共享，可以通过Car.odometer_reading访问

__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数

使用类的名称 Car来实例化，并通过 __init__ 方法接收参数

访问属性

增加修改删除类的属性

定义

优点

类方法的特点

方法使用场景

指多个类之间的所属关系，及子类默认继承父类的所有属性和方法

注意

单继承

多继承

子类和父类拥有同名属性和方法，用子类去创建对象，该对象调用同名属性和方法，调用的是子类里面封装的属性和方法

用父类方法，为保证调用到的是父类属性，必须在调用前调用父类初始化

关联父类子类

多层继承中使用

写法

注意

一种使用对象的方式，子类重写父类的方法，调用不同的子类对象的相同父类方法，可以产生不同的执行结果

调用灵活，有了多态更容易编写通用的代码，做出通用的编程，以适应需求的不断变化

定义父类，并提供公共方法
定义子类，并重写父类方法
传递子类对象给调用者，可以看到不同子类执行效果不同

需要通过装饰器@staticmethod来进行修饰，静态方法既不需要传递类对象，也不需要传递实例对象（形参没有self/cls）
静态方法也能通过实例对象和类对象访问

当方法中既不需要使用实例对象（如实例对象，实例属性），也不需要使用类对象（如类属性，类方法，创建实例属性）时，定义静态方法
取消不需要的参数传递，有利于减少不惜要的内存占用和性能消耗

import math
print(math.sqrt(9))

from math import sqrt

print(sqrt(9))

from math import *

print(sqrt(9))

import time as tt
tt.sleep(2)
print('hello')

from time import sleep as sl
sl(2)
print('hello')

import mypackage.my_module1
mypackage.my_module1.info_print1()

from mypackage import *
my_module2.info_print1()