Python 基础语法

最新推荐文章于 2024-05-30 09:45:12 发布
最新推荐文章于 2024-05-30 09:45:12 发布
阅读量205 收藏
点赞数
文章标签： python
原文链接：https://juejin.im/post/5c0dba53f265da6124154679
版权

算数运算符

符号作用说明
+加计算两个数的和
-减计算两个数的差
*乘计算两个数的乘积
/除计算两个数的商
//整除两个整除相除后，取结果的整数部分
%取余两个整数相除后，取结果的余数部分
**乘方计算a的b次方

变量语法格式

  • 定义变量：变量名 = 值
  • 使用变量：变量名

变量类型

名称中文名称作用
int整型表示所有的整数
float浮点型表示所有的小数
bool布尔型表示逻辑值
str字符串表示字符串信息

赋值运算符

符号作用格式
=赋值a = b ,将b的值给a
+=加后赋值a+=b，将a+b的值给a
-=减后赋值a-=b,将a-b的值给a
*=乘后赋值a*=b，将a*b的值给a
/=除后赋值a/=b, 将a/b的值给a
//=整除后赋值a//=b,将a//b的值给a
%=取余后赋值a%=b,将a%b的值给a
**=次方后赋值a**b,将a的b次方的值给a

注意事项

  1. 基本赋值运算=操作，左侧只能是变量，右侧可以是任意数据或变量
  2. 特殊赋值运算的左侧只能是变量，右侧可以是变量，也可以是数字
name = "张三丰"
ferst_name = "张"
last_name = "三丰"
print(first_name + last_name)

print(name * 3)

# 字符串连接运算+不能在字符串类型与其他类型间进行操作
复制代码

输入/输出

  1. 语法格式
  • 格式一：input()
  • 格式二：input("提示信息")
  1. 输入数据的接收
  • 格式一：变量 = input()
  • 格式二：变量 = input("提示信息")

输出

  1. 语法格式
  • 格式一：直接输出变量
  • print（变量）
  • 格式二：输出包含单个占位符字符串的信息
  • print（"包含1个占位符的格式化字符串" % 变量）
  • 格式三：输出包含多个占位符字符串的信息
  • print("包含多个占位符的格式化字符串" % （变量1，变量2，...)
  1. 输出占位符
占位符作用
%s字符串
%d整数
%6d整数，数字用于设置位数（最小值），不足不空白
%f浮点数
%.4f设置小数位数，四舍五入，省略数字表示取整
%%输出%
........
  1. 数据转型
  • input函数接收的数据默认为字符串类型
  • 接收整数：字符串->整型数据：int（“整数格式的字符串”）
  • 接收小数：字符串->浮点型数据：float(“小数格式的字符串”)

分支语句

  1. 常用比较运算符
符号说明
==判断两个操作数的值是否相等，成立为True
!=判断两个操作数的值是否不相等，成立为True
>判断左操作数是否大于右操作数，成立为True
<判断左操作数是否小于右操作数，成立为True
>=判断左操作数是否大于等于右操作数，成立为True
<=判断左操作数是否小于等于右操作数，成立为True
  1. 真值表
andTrueFalse
TrueTrueFalse
FalseFalseFalse

#逻辑与：同真则真

orTrueFalse
TrueTrueTrue
FalseTrueFalse

#逻辑或：同假则假

。。TrueFalse
notFalseTrue

#逻辑非：非真即假，非假即真 3. 分支语法格式

  • 格式一：
if 条件：
    条件成立执行的代码
    
#演示
x = 150
if x > 100:
    print(x)
    
print("结束")
复制代码
  • 格式二：
if 条件：
    条件成立执行的代码
else:
    条件不成立执行的代码
    
#演示
a = 2
b = 10
if a >= b:
    print(a)
else:
    print(b)
    
复制代码
  • 格式三
if 条件1：
    条件1成立执行的代码
elif 条件2：
    条件2成立执行的代码
elif 条件3：
    条件3成立执行的代码
    ....
else:
    条件都不成立执行的代码

#演示
score = 73
if score == 100:
    print ("买自行车，可拉风了")
elif score >=95 and score < 100:
    print("去游乐场玩，可HAPPY了")
elif score >=90 and score < 95:
    print("买玩具，你们都没有")
elif score >= 80 and score < 90:
    print("没事，哥还活着")
else：
    print("小心你的屁屁")
    
print("结束")
复制代码
  1. 超长出来方案
  • 方案一：换行处理使用\
  • 方案二：对整体添加（），（）中随意换行

while循环语句

  1. while循环的基本语法
while 条件：
    反复执行的代码
        ....
        
#演示
#通常使用循环变量来控制循环的执行数
i = 1
#循环从while开始，后面添加条件
while i <= 3:
#while 下面添加要反复循环的语句
    print("hello python")
    i += 1
    
#如果没有判断值范围可以使用True或False，True是执行，False不执行。
复制代码
  1. 循环的终止与跳出
  • break可以用于终止循环的执行，当执行到break语句后，程序将跳出循环，执行循环语句后面的代码
#演示break功能
i = 1
while i <= 10:
    #如果查到了5，结束循环
    if i == 5:
        break
    print("查数：%d" % i)
    i += 1
    
print("结束")
复制代码
  • conthnue 可以用于提前结束本轮循环的执行，当执行到continue语句后，程序将跳到判定循环是否向下执行的条件处，进行下一轮循环是否执行的判定与后续代码执行
#演示continue功能
i = 0 
while i < 10:
    #如果碰到5，则直接跳过，查下面的数字
    if i %2 == 0:
        continue
    print("查数：%d" % i)
print("结束")
复制代码

#**注意：**break与continue必须出现在循环体中 3. 循环嵌套的基本语法：

while 条件：
    while 条件:
        反复执行的代码：
        ....
    ....
    
#演示
j = 1
while j <= 5:
    i = 1
    while i <= 3:
        print(i)
        i += 1
    j +=1
    
复制代码

#注意： break与continue仅能控制其所在的循环结构，不能控制其他循环结构

函数

  1. 无参函数语法格式
定义格式：
    def 函数名():
        函数体
        ...
    
#演示
def say ():
    print("hello 北京")
    print("hello 中国")
    print("hello python")
    
调用格式：
    函数名()

#演示

def say ():
    print("hello 北京")
    print("hello 中国")
    print("hello python")
    
say()#调用
复制代码
  1. 有参数函数语法格式
定义格式：
    def 函数名(参数)：
        函数体
        ...
        
#演示
def sun(a)#a = 100,a是参数，形参
    """用于计算1到指定数字的和"""
    i = 1
    sums = 0
    while i <= a:
        sums += i
        i +=1
    print(sums)

调用格式：
    函数名(参数)
    
#演示
def sun(a)#a = 100,a是参数，形参
    """用于计算1到指定数字的和"""
    i = 1
    sums = 0
    while i <= a:
        sums += i
        i +=1
    print(sums）
    
sum（10）#10是参数，实参
复制代码
  1. 有返回值函数语法格式
def 函数名(参数)：
    函数体
    return 函数运行结果返回值
    ...
    
#演示
def test():
    print("我要将1返回给函数调用处")
    return 1
    #return返回
x = test()


调用格式：
变量名 = 函数名(参数)

#演示
def test():
    print("我要将1返回给函数调用处")
    return 1
    
x = test()#调用
复制代码
  1. 作用域
  • 提升局部变量为全局变量的语法格式：
  • global 变量名
  1. 函数间调用
def add(a,b):
    return a+b
    
def div(a,b):
    return a/b
    
def get(a,b):
    #先计算和
    c = add(a,b)
    #再计算平均值
    d = div(c,2)
    return d
    
x = get(1000,2000)
print(x)
复制代码

面向对象

  1. 类定义语法格式：
class 类名：
    pass
    
#演示
class Cat:
    pass
    
#说明：pass是空语句，不具有任何意义，仅为了保持程序结构完整性
复制代码
  1. 创建对象语法格式
  • 对象名 =（）类名
class Cat:
    pass
    
#创建对象
cat1 = Cat()

#注意：对象的创建不限制数量，一个类可以创建任意个数的对象
复制代码
  1. 定义成员变量语法格式（公有属性/公有变量）
class 类名：
    def __init__(self):
        self.变量名1 = 值1
        self.变量名2 = None
        
#演示
class Cat:
    def __init__(self):
        self.type = "波斯猫"
        self.name = None
        
复制代码
  1. 成员变量定义语法格式(独有属性/独有变量)
对象名.变量名 = 值

class Cat:
    def __init__(self):
        self.type = "波斯猫"
        self.name = None
        
cat1 = Cat()
print(cat1.type)
cat.name = "大帅"
print(cat1.name)
#给cat1穿衣服
cat1.cloth = "红色"
#独有属性
复制代码
  1. 变量的调用格式
  • 取值：对象名.变量名
  • 赋值：对象名.变量名 = 值
  1. 定义成员方法语法格式
格式一（无参方法）：
class 类名：
    def 方法名(self):
        方法体
        
#演示
class Cat:
    def __init__(self):
        self.type = "波斯猫"
        self.name = None
        
    def eat(self):
        print("猫吃鱼")
        

格式二（有参方法）：
class 类名：
    def 方法名(self,形参1，形参2，...):
        方法体
        
#演示
class Cat:
    def __init__(self):
        self.type = "波斯猫"
        self.name = None
        
    def eat(self):
        print("猫吃鱼")
        
    def climb(self,meter):
        print("猫会爬树，爬了%d米" % meter)
        
复制代码
  1. 调用成员方法语法格式
格式一（调用无参方法）
对象名.方法名（）
#演示
class Cat:
    def __init__(self):
        self.type = "波斯猫"
        self.name = None
        
    def eat(self):
        print("猫吃鱼")
        
    def climb(self,meter):
        print("猫会爬树，爬了%d米" % meter)
        
cat1 = Cat（）
cat1.eat()#调用

格式二（调用有参方法）：
对象名.方法名（实参1，实参2，...）

#演示
class Cat:
    def __init__(self):
        self.type = "波斯猫"
        self.name = None
        
    def eat(self):
        print("猫吃鱼")
        
    def climb(self,meter):
        print("猫会爬树，爬了%d米" % meter)
        
cat1 = Cat（）
cat1.eat()
cat1.climb(15)#调用
复制代码
  1. 定义__init__方法语法格式
格式一：
def __init__(self):
    self.变量名1 = 值1
    
#演示
class Cat：
    def __init__(self):
        self.type = "波斯猫"
        self.type = None
        
格式二：

def __init__(self,形参1，形参2，...):
    self.__属性名1 = 形参1
    self.__属性名2 = 形参2
    
#演示
class Cat:
    def __init__(self,type,name):
        self.__type = type
        self.__name = name
   
   
#注：
__init__方法在创建对象时被运行，无需手工调用即可执行
__init__方法如果有形参，在创建对象时需要传递对应的实参
复制代码
  1. 定义__str__方法语法格式
def __str__(self):
    return 打印对象时显示的信息
    
#演示

class Cat:
    def __init__(self):
        self.type = "波斯猫"
        self.name = None
        
    def eat(self):
        print("猫吃鱼")
        
    def climb(self,meter):
        print("猫会爬树，爬了%d米" % meter)
        
    def __str__(self):
        return "打印一只猫"
        
cat1 = Cat（）
cat1.eat()
cat1.climb(15)
复制代码
  1. 成员方法中调用成员变量语法格式
self. 变量名

#演示

class Cat:
    def __init__(self):
        self.type = "波斯猫"
        self.name = None
        
    def introduce(self):
        print("我是一只%s,我叫%s,我穿的衣服是%s" % (self.type,self.name,self.color))

cat1=Cat()
cat.name = "大帅"
cat1.color = "红色"
cat1.introduce()
复制代码
  1. 成员方法中调用成员方法语法格式
self.方法名(实参1，实参2,...)

#演示
class Cat:
    def catch(self):
        self.jump()
        self.grasp()
        self.bite()
        
    def jumb(self):
        print("猫跳起来")
        
    def grasp(self):
        prrint("猫抓住了老鼠")
        
    def dite(self):
        print("猫咬住了老鼠")
        
cat1 = Cat()
cat1.catch()
#self仅出现在成员方法中，指代执行该方法的对象。
复制代码
  1. 定义私有变量语法格式（封装）
self.__属性名 = 值

#演示
class Card:
    def __init__(self):
        self.carld_id = None
        self.__pwd = None#私有属性
        
复制代码
  1. 定义私有方法语法格式(封装)
def __方法名（self，形参1，形参2，...）:
    方法体
#演示
class Card:
    def __init__(self):
        self.card_id = None
        self.__pwd = None
        
    def __get_pwd(self):
        return self.__pwd
        
复制代码
  1. 标准封装语法格式
变量私有化格式：
self.__属性名 = 值

提供公共访问器格式：
def get_属性名（self）：
    return self.__属性名
    
提供公共的修改器格式：
def set_属性名（self.属性名）：
    self.__属性名 = 属性名
    
#演示
class Card:
    def __init__(self):
        self.card_id = None
        self.__pwd = None
        
    def get_pwd(self):
        return self.__pwd
        
    def set_pwd(self.pwd):
        self.__pwd = pwd
        
复制代码
  1. 定义类变量语法格式
class 类名：
    变量名 = 值
    
复制代码
  1. 调用类变量语法格式
赋值格式：
    类名.类变量名 = 值
    
取值格式：
    类名.类变量名（推荐）
    对象名.类变量名（不推荐）
    
复制代码
  • 类变量推荐使用类名取值访问，也可以使用对象名取值访问
  • 类变量只能通过类名修改：使用对象名调用变量修改类变量的值时会创建新的对象独有变量；如果此时对象具有同名对象变量，则修改对应的变量值
  • 类变量可以私有化
  1. 定义类方法基本语法
class 类名：
    @classmethod
    def 方法名（cls,形参1，形参2，...）:
    
#演示
class Chinese:
    country = "中国"
    def __init__(self,id_num,name):
        self.id_num = id_num
        self.name = name
        
    @classmethod
    def show_country(cls):
        print("我是中国人")
        
复制代码
  1. 调用类方法语法格式
  • 类名.类方法名（实参1，实参2，...）
  • 对象名.类方法名（实参1，实参2，...）(不推荐)
  1. 定义静态方法语法格式
class 类名：
    @statimethod
        def 方法名（形参1，形参2，....）:
            方法体
            
class Chinese:
    country = "中国"
    def __init__(self,id_num,name):
        self.id_num = id_num
        self.name = name
        
    @staticmethod
    def show()
        print("今天天气不错")
        
复制代码
  1. 调用静态方法语法格式
  • 类名.静态方法名（实参1，实参2，...）（推荐）
  • 对象名.静态方法名（实参1，实参2，...）(不推荐)

继承

  1. 继承语法格式
class 类名（父类名）：
    pass
    
#演示
class Animal:
    pass
    
class Cat(Animal):
    pass
    
复制代码
  1. 获取继承关系图谱
  • 使用Python内置属性__mro__可以查看继承关系
  • 语法格式：类名.mro
class Animal(object):
    def showl(self):
        pass
        
class Cat(Animal):
    def show2(self):
        pass
        
class PersianCat(Cat):
    def show3(self):
        pass
        
        
#(<class '__main__,Animal'>，<class 'object'>)
print(Animal.__mro__)
#(<class '__main__,Cat'>,<class '__main__,Animal>,<class'object'>)
print(Cat.__mro__)
复制代码

2.重写的作用

  • 子类对父类的成员方法进行重写后，使用子类对象调用该方法时，将执行子类中重写的方法
class Animal(object):
    def showl(self):
        print("动物吃东西")
        
class Cat(Animal):
    def show2(self):
        prtin("猫吃鱼")
        
cat1 = Cat()
cat1.eat()
print(cat1)

复制代码
  1. 在子类中访问父类被重写的方法
  • 格式一：
  • 父类名.方法名（对象）
  • 格式二：
  • super(本类名.对象).方法名（）
  • 格式三：（推荐）
  • super().方法名（）
class Animal(object):
    def showl(self):
        print("动物吃东西")
        
class Cat(Animal):
    def show2(self):
        prtin("猫吃鱼")
        #调用格式一：父类名.方法名（对象）
        Animal.eat(self)
        #调用格式二：super(本类名，对象).方法名（）
        super(Cat,self).eat()
        #调用格式三：super().方法名（）
        super().eat()
        
复制代码
  1. 多继承语法格式
class 类名（父类名1，父类名2..）:
    pass
    
#演示
class Father:
    pass
class Mother:
    pass
class Child(Father,Mother):
    pass
    
复制代码

数据存储

  1. 列表的基本语法
  • 创建列表： 变量名 = [数据1，数据2，...]
  • 获取列表数据： 变量名[索引]
  • 修改列表数据：变量名[索引]= 值
list1 = [1,2,3,'itcast',"heima",True,False,None]
print(list1[4])#获取列表中指定索引的数据
list1[4] = "黑马程序员"#修改列表中指定索引的数据
复制代码
  1. 列表常用方法
方法名功能参数返回值范例
append(data)关键词：追加在列表的末尾添加数据data:加入到列表中的数据Nonelist1 = [1,2,3] ;list1.append("itcast")
insert(idx.data)关键词：插入在列表的指定位置插入数据idx：插入数据的索引位置，data：加入列表中的数据Nonelist1 = [1,2,3] ；list1.insert(0,"itcast")
extend(model)关键词：追加全部在列表的末尾添加参数对象中的所有数据model:保存有数据的存储模型，该模型接受列表、元组、集合类型的对象Nonelist1 = [1,2,3]；list2 = [4,5,6]；tuple2 = (7,8,9)；set2 = {10,11,12}；list1.extend(list2)；list1.extend(tuple2)；list1.extend(set2)
remove(data)关键词：删除从列表中删除指定的数据，如果数据不存在将报错data:要从列表中删除的数据Nonelist1 = [1,2,3,"itcast"];list1.remove("itcast")
pop(idx)关键词：获取删除从列表中获取并删除指定索引位置上的数据，如果索引值超过列表数据总量将报错idx:要从列表中获取的数据对应的索引位置获取到的数据list1 = [1,2,3,"itcast"];data = list1.pop(2)
index(data)关键词：查询位置查询列表中指定数据对应的索引，如果数据不存在将报错data:在列表中要查询的数据查询数据第一次出现的索引list1 = [1,2,3,"itcast"];idx = list1.index("itcast")
count(data)关键词：统计数量统计列表中指定数据出现的数量data:在列表中要统计数量的数据统计数据出现的次数list1 = [1,2,3,"itcast"];num = list1.count("itcast")

3.元组的基本语法

  • 创建元组：变量名=（数据1，数据2，...）
  • 获取元组数据： 变量名[索引]
tuple1 = ("itcast","No",1)
print(tuple1[1])#获取元组中指定索引的数据
复制代码
  1. 元组常用方法
方法名功能参数返回值范例
index(data)关键词：查询位置查询元组中指定数据对应的索引，如果数据不存在将报错data:在元组中要查询的数据查询数据第一次出现的索引tuple1 = [1,2,3,"itcast"];idx = tuple1.index("itcast")
count(data)关键词：统计数量统计元组中指定数据出现的数量data:在元组中要统计数量的数据统计数据出现的次数tuple1 = [1,2,3,"itcast"];num = tuple1.count("itcast")
  1. 集合的基本语法
  • 创建集合：变量名 = [数据1，数据2，...]
set1 = {1,2,3"itcast"}
复制代码
  1. 集合常用方法
方法名功能参数返回值范例
add(data)关键词：添加在集合中添加数据data:加入到集合中的数据Noneset1 = {1,2,3}；set1.append("itcast")
remove(data)关键词：删除从集合中删除指定的数据，如果数据不存在将报错data:要从集合中删除的数据Noneset1 = {1,2,3,"itcast"}；set1.remove("itcast")
pop()关键词：获取删除从集合中获取并删除第一个数据无获取到的数据set1 = {1,2,3,"itcast"}；data = set1.pop()
clear()关键词：清空清空集合中的数据无Noneset1 = {1,2,3,"itcast"}；set1.clear()
  1. 字典的基本语法
  • 创建字典：变量名= {键1：值1，键2：值2，....}
  • 添加数据：变量名[键] = 值 （字典中没有对应的键）
  • 获取数据: 变量名[键]
  • 修改数据：变量名[键]=值（字典中存在对应的键）
dict1 = {"name":"itcast","age":11}
dict1["address"] = "北京"#添加键为address的数据
dict1["age"]=12#修改键为age的数据
dict1["name"]#获取键为name的数据
复制代码
  1. 字典常用方法
方法名功能参数返回值范例
pop(key)关键词：删除获取从字典中删除指定键key对应的键值对，如果键key不存在将报错key:要删除的值value对应的键key被删除的值valuedict1 = {"name":"itcast","age":11};v = dict1.pop("name")
popitem()关键词：删除从字典中删除指定键key对应的键值对，如果键key不存在将报错key:要删除的键值对对应的键key被删除的键值对，以元组的形式返回dict1 = {"name":"itcast","age":11};v = dict1.popitem()
clear()关键词：清空清空字典中的数据无Nonedict1 = {"name":"itcast","age":11}：dict1.clear()
setdefault(key,value)关键词：检测添加添加新的键值对，如果存在对应的键，则忽略该操作key:要添加的新键值对对应的键key
value: 要添加的新键值对对应的值value字典中key对应的值，如果是添加则返回参数value，如果不是添加，返回原始key对应的valuedict1 = {"name":"itcast","age":11};dict1.setdefault("age",22)
update(dict)关键词：更新数据使用新字典中的数据对原始字典数据进行更新dict：新字典对象Nonedict1 = {"name":"itcast","age":11}；dict2 = {"address":"北京","age":22}；dict1.update(dict2)
get(key)关键词：获取根据键key查询字典中对应的值，如果键key不存在将返回Nonekey:要查询的键key根据键key在字典中查询的值valuedict1 = {"name":"itcast","age":11}；v = dict1.get("age")
items()关键词：获取键值对列表获取字典中所有的键值对列表数据无由键值对组成的列表，键值对的格式是元组数据dict1 = {"name":"itcast","age":11};dict1.items()
  1. 格式转换
header 1转换成列表转换成元组转换成集合
列表list--tuple(列表对象)set（列表对象）
元组tuplelist（元组对象）--set（元组对象）
集合setlist（集合对象）tuple（集合对象）--
  1. for循环基本语法
for 变量名 in 列表：
    变量相关操作
    
#演示
list = [1,2,3,"itcast"]
for data in list1：
    peint（data）
    
复制代码
  1. range的基本语法
  • 格式1：range(m) 生成0到m-1的整数
  • 格式2：range(m,n) 生成m到n-1的整数
  • 格式3：range(m,n,s) 生成m到n-1的整数，整数间隔为s
r1 = range(10)#从0到10，不包含10，每次递增1，共10个整数
r2 = range(5,10)#从5到10，不包含10，每次递增1，共5个整数
r3 = range(5,10,2)#从5到10，不包含10，每次递增2，共2个整数5,7,9
复制代码
  1. range的应用场景
1.配合foe循环构造指定次数的循环
for _ in range(..):
    循环执行的代码
    
2.快速创建有连续的整数作为数据的列表、元组、集合对象
list(range(..))
tuple(range(..))
set(range(..))
复制代码
  1. 公共方法
方法名功能参数返回值范例
len(model)关键词：数据总量获取容器模型中的数据总量model:保存有数据的存储模型，该模型接受各种容器容器模型中数据的总量list1 = [1,2,3,'itcast',"heima"];length = len(list1)
max(model)关键词：最大值获取容器模型中的最大值，对于字典获取字典的键key的最大值model:保存有数据的存储模型，该模型接受各种容器容器模型中数据的最大值list1 = [1,2,3,4,5];max_value = max(list1)
min(model)关键词：最小值获取容器模型中的最小值，对于字典获取字典的键key的最小值model:保存有数据的存储模型，该模型接受各种容器容器模型中数据的最小值list1 = [1,2,3,4,5];min_value = min(list1)
  1. 切片基本语法
  • 容器对象[开始索引：结束索引：步长]
  1. 通用运算符
运算符功能格式适用范围
+将两个容器数据合并放入第一个容器list1+list2列表之间或元组之间（列表与元组之间报错）
*将容器数据赋值n次放入容器中list1*n列表、元组
in判断容器中是否包含数据data in list1列表、元组、集合、字典（字典判断数据是否在keys（）中）
not in判断容器中是否不包含数据data not in list1列表、元组、集合、字典（字典判断数据是否不在keys（）中）
>、>=、==、<=、<比较两个容器中数据关系list1 <= list2列表、元组、集合
  1. for...else 基本语法
for 变量名 in 列表：
    变量相关操作
else：
    循环正常运行结束后执行的操作
    
#演示
for data in range(5):
    print(data)
else:
    print("end")
#注：
1.如果for循环中执行了break语句，则else中的代码将不执行
2.while循环同样具有while...else语法格式
复制代码
  1. 推导式基本语法
基础语法格式：
循环变量 for 循环
范例：
list1 = [data for data in range(5)]

数据处理语法格式：
表达式 for 循环
范例：
list1 = [data*5 for data in range(5)]

数据过滤语法格式：
表达式 for 循环 if 判断
范例：
list1 = [data for data in range (5) if data > 200]

复制代码

字符串

  1. 创建字符串基本语法
  • 变量名 = "字符串信息"
  • 变量名 = '字符串信息'
  • 变量名 = """字符串信息"""
  • 变量名 = '''字符串信息'''
  1. 字符串切片基本语法
  • 字符串[开始索引：结束索引]
  • 字符串[开始索引：结束索引：步长] 3.字符串基本操作
操作格式/函数名称功能参数返回值范例
变量名[idx]关键词： 获取单个字符获取字符串中指定索引位置的字符idx:要获取的索引位置结果是包含了单个字符的字符串info = "itcast"；s = info[3] 结果："a"
str1 in str2关键词：包含判断一个字符串str2是否包含另一个字符串str1str1:比对字符串对象；str2:原始字符串对象结果是True或Falsestr1 = "cast"；str2 = "itcast"；str2 in str1 结果：False；str1 in str2 结果：True
len(str)关键词：长度本操作是一个函数，无须用字符串对象调用，用于获取一个字符串中所包含的字符数量str:字符串对象结果是一个int整数info = "itcast"；len(info) 结果：6
max(str)关键词：最大值本操作是一个函数，无须用字符串对象调用，用于获取字符串中排序最大的字符str:字符串对象结果是一个包含了单个字符的字符串info = "itcast"；max(info) 结果："t"
min(str)关键词：最小值本操作是一个函数，无须用字符串对象调用，用于获取字符串中排序最小的字符str:字符串对象结果是一个包含了单个字符的字符串info = "itcast"；max(info) 结果："a"
  1. 状态获取操作
方法名功能参数返回值范例
islower()关键词：是否全小写判断字符串是否是全小写字母组成无结果是True或Falseinfo1 = "itcast"；info1.islower() 结果：True；info2 = "ITHEIMA"；info2.islower() 结果：False
isupper()关键词：是否全大写判断字符串是否是全大写字母组成无结果是True或Falseinfo1 = "itcast"；info1.issupper() 结果：False；info2 = "ITHEIMA"；info2.issupper() 结果：True
startswith(str)关键词：判定前缀判断字符串是否以指定字符串开始str:用于作为判定条件的字符串对象结果是True或Falseinfo = "logo.png"；info.startswith("lo") 结果：True
endswith(str)关键词：判定后缀判断字符串是否以指定字符串结束str:用于作为判定条件的字符串对象结果是True或Falseinfo = "logo.png"；info.endswith(".png") 结果：True
  1. 字符串转换操作
  2. 格式化转换操作
方法名功能参数返回值范例
strip (str)关键词：左右去字符去掉字符串左右两侧在参数字符串中包含的所有字符str:包含了若干个字符的字符串结果是一个字符串str1 = " itcast ";str1.strip(" ");结果："itcast";str2 = "itcast";str2.strip("it") 结果："cas";str3 = "itcast";str3.strip("sat") 结果："itc"
center (len,str)关键词：左右两侧补占位符使用指定字符在原始字符串两侧补充到长度为指定值，左侧补充数量≥右侧补充数量len:补充字符后的字符串长度
str:补充的字符，如果使用多个字符组成的字符串将报错结果是一个字符串str1 = "itcast";str1.center(10,"6") 结果:"66itcast66";str1.center(11,"6") 结果:"666itcast66";str1.center(5,"6") 结果:"itcast";str1.center(10,"66") 结果:报错
  1. 拆分操作
  2. 连接操作
  3. 查询操作
  4. 替换操作
  5. 其他操作

高级函数

  1. 默认参数基本语法
定义格式：
def 函数名（形参1 = 值1，...）:
    函数体
    ...
    
调用格式一（同普通参数，无特殊）：
函数名（实参）：使用实参为形参的值，不适用默认值

调用格式二：
函数名（） 使用默认值作为形参的值

#演示
def test(a=2,b=5):
    print(a)
    print(b)
test()
复制代码
  • 注意事项
  • 默认参数的定义必须在位置参数的右侧
def test(b = 100,a)#位置参数在默认参数右侧，报错
    pass
复制代码
  • 默认参数在调用传值时，按照位置参数进行对待，从左至右依次赋值，不能跳过左侧的某个参数直接为后面的参数赋值
def test(a,b = 2, c = 3)
    pass
test(100,200,300)
复制代码
  1. 关键字参数基本语法
定义格式（同普通参数定义，无特殊）：
    def 函数名（形参，...）:
    ...
    
调用格式：
函数名（形参名 = 实参）

#演示
def test(a = 100,b = 200):
    pass
    
test(b = 1)
复制代码
  • 注意事项
  • 关键字参数必须出现在位置参数的后面
def test(a = 100, b = 200):
    pass
    
test(a = 1, 2)#关键字参数出现在位置参数的左侧，报错
复制代码
  • 不允许使用关键字参数对同一个形参进行多次赋值
def test(a = 100, b= 200):
    pass
    
test (a = 1,a =  2, b=3)#使用关键字参数为a赋值了两个，报错

def test(a = 100, b=200):
    pass
    
test(1 , a = 2,b = 3)
#即使用位置参数为a赋值1，又使用关键字参数为a赋值2
复制代码
  • 关键字参数即可以为位置参数赋值，也可以为默认参数赋值，通常使用关键字参数解决默认参数选择性赋值问题。
  1. 可变参数基本语法
定义格式：
def 函数名（*args，...）:
    函数体
    ...
    
调用格式（同普通参数，无特殊）

函数名（实参1，...）

#演示
def test(*args):
    pass
    
test(1,2,3,4,5)
复制代码
  • 注意事项
  • 可变参数在一个函数/方法定义中只能出现一个
def test(*args,*args2):#声明了多个可变参数，报错
    pass
    
test（1,2,3）
复制代码
  • 可变参数只能出现在位置参数的后面，位置参数在左侧，可变参数在右侧
def test(*args,a):#可变参数必须在位置参数的右侧，报错
    pass
    
test（1,2,3,4,5）
复制代码
  • 默认参数只能出现在位置参数的后面，赋值时必须使用默认参数传值，否则值会被可变参数接收
def test(a,b,*args,c)#c无法接收到传递的值4，报错
    print(*args)
    
test（1，2,3,4）
复制代码
  • 定义函数的参数时，先定义位置参数，再定义可变参数，最后定义默认参数
def test(a,b,*args,c=1):
    pass
复制代码
  1. 字典参数基本语法
定义格式：
    def 函数名（**kwargs,...）:
    函数体
    ...
    
调用格式：
函数名（未定义的变量名1 = 实参1，未定义的变量名2 = 实参2，...）

#演示
def test(**kwargs):
    pass
    
test(a = 1,b = 2)
复制代码

-注意事项

  • 字典参数在一个函数/方法定义中只能出现一个
def test(**kwargs,**wkargs2):#多个字典参数，报错
    pass
    
test(a = 1,b = 2)
复制代码
  • 定义函数的参数时，先定义位置参数，再定义可变参数，然后定义默认参数，最后定义字典参数
def test(a,b,*args,c=200,**kwargs):
    pass
    
复制代码
  1. 递归函数
  • python语言中函数调用最大层级为1000层，超过该层级，程序将报错（不同语言设置不用）
  1. 匿名函数基本语法
格式一：
定义： 变量名 = lambda 形参 ：返回值

调用： 结果 = 变量名（实参）

#演示

add = lambda a,b : a + b
c = add(3,4)

格式二：
定义并调用： 结果 = （lambda 形参 ：返回值）（实参）

c = (lambda a,b : a+b)(5,4)
复制代码
  1. 匿名函数特殊语法
  • 无参格式 ： 结果 = （lambda : 返回值）（）
f1 = (lambda : 100)()
复制代码
  • 多返回值格式： 无，可使用数据存储模型返回多个数据
  • 无返回值格式： 无 ，必须有具体值或结果为None

引用

  • 获取内存存储地址语法格式：
id (数据)
id （变量名）
#演示
a = 1
print(id(1))
print(id(a))
复制代码

对象管理

  1. __new__方法定义
  • 定义__new__方法时对object类中__new__方法的重写，重写该方法时必须再次调用object类中的__new__方法。
def __new__(cls,*args,**kwargs):
    #用户自定义的操作内容
    #。。。
    #创建对象由object完成，需要是定创建的类名称
    intance = object.__new__(类名)
    #将创建出对象返回出去，继续完成后操作
    return instance
    
复制代码
b10l07
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SM2259XT3！？继SM2259XT2、SM2259XT、SM2258XT、SM2246XT之后，慧荣新主控SM2259XT3量产固件、开卡工具
SDN_WOSHI_LAO_DA的博客
12-31 2016
根据量产业界权威网站量产部落的收录，目前量产部落已发布SM2259XT3_BGA144的原理图，等到SM2259XT3开始正式出货，相信不久之后就会有相关SM2259XT3 MPTool量产固件、开卡工具发布出来，DIYer未来可期。
SM2246XT量产教程，闪迪ssd plus固态硬盘慧荣主控不识别开卡成功
2301_76356838的博客
12-27 5393
5、尺寸2.5寸，6、点击save保存，一定要保存）准备工具：尖头镊子，坏固态硬盘，sata转USB转接卡(没有转接卡的可以试试直接插主板开卡，我没有试过，我不对任何问题负责)，慧荣sm2246XT开卡工具（建议多下几个版本）自己的闪迪的120g固态突然挂了，打售后电话被告知刚刚过保，气死人啊，于是死马当活马医，网上搜了搜，貌似可以开卡成功，于是开始动手操作，别说，还真的救回来了。打开慧荣sm2246XT_MPTool，这里要说一下，量产工具有很多版本，有的版本你可能用不了，可以从量产部落网多下几个备用。
固态硬盘坏了怎么修，固态硬盘开卡维修常识性知识，SSD量产开卡基础教程
最新发布
2401_83242027的博客
05-30 1300
每个主控需要用各自对应的量产工具，不同的量产工具支持的闪存颗粒也有差异，因此一定要根据固态硬盘实际的主控型号、闪存制程、缓存（如果有缓存的话）去。如下图是一个拆开的慧荣SM2246XT主控的固态硬盘，注意看下图，板子右侧有一个ROM的标识，字母边上的两个洞就是进入工程模式的短接点位置。如下图是一个拆开的慧荣SM2246EN主控的固态硬盘，注意看下图，板子左侧有一个ROM的标识，字母边上的两个洞就是进入工程模式的短接点位置。3、闪存芯片：FLASH闪存芯片、闪存颗粒，是固态硬盘存储数据的芯片。
SM2269XT量产工具下载，SM2269XT+YMTC_TAS开卡成功，附SM2269XT量产工具、开卡软件
2401_83242027的博客
03-07 601
我是在这个量产部落下载的，挺全的，别的地方也没有SM2269XT的软件。
DIY一个SM2269XT+B47R开卡量产测试，附SM2269XT量产工具、开卡软件
2401_83242027的博客
03-07 531
我是在量产部落下载的，挺全的，别的地方也没有SM2269XT的软件。
DIY USB3.0 SM2246XT+双贴闪迪15131颗粒256G固态U盘
m0_55207244的博客
08-01 5451
扫描U盘，焊接之前请先插上空板子检测量产工具或者diskgenius分区工具是奋可以检测到（正常的板子会显示1024），，这里显示的是芯片的ID和CE数量，可以判断每个通道是否正常焊接暨是否识别。你能来想DIY固态U盘说明你已经差不多具备焊接的知识了，主要说明的一个焊接事项就是我自己使用的。焊接部分就不做详细介绍了，图文方式没办法很好的阐述，不懂焊接手法的可以看看相关视频教学。7.可以根据自己需要修改，这里就修改U盘型号和供应商为自己喜欢的名称。5.上面两步都没问题后，就可以进入设置页面。...
Python基础语法合集.pdf
06-06
Python是一种高级编程语言，以其简洁明了的语法...以上就是Python基础语法的主要内容，包括基本的输入输出、变量命名、条件判断和数据类型。学习这些基础知识是掌握Python编程的第一步，对于进一步的编程实践至关重要。
python基础语法合集68页.pdf
05-08
在实际编程中，了解这些基础知识是学习Python的第一步，它们构成了Python语法的核心，为后续的进阶学习和实际项目开发打下坚实基础。无论是初学者还是有经验的程序员，熟悉并掌握这些基本概念和用法都是至关重要的。
python基础语法入门
05-01
例如卡耐基梅隆大学的编程基础、麻省理工学院的计算机科学及编程导论就使用Python语言讲授。众多开源的科学计算软件包都提供了Python的调用接口，例如著名的计算机视觉库OpenCV、三维可视化库VTK、医学图像处理库ITK...
python基础语法
12-21
【Python基础语法】 Python是一种高级编程语言，以其简洁明了的语法著称。在Python中，代码的逻辑主要通过缩进来表示。每行代码的缩进通常为4个空格，这使得代码看起来整洁且易于阅读。注释可以通过在行首添加`#`来...
SM2244和SM2250固态硬盘量产工具L0409A
12-17
http://www.whjldn.com/215.html 我复制别人的资源 两年前买的LONGSYS 64G M6固态硬盘ssd，其主控SM2244G AB，一直做系统盘用，win7的系统，前两天突然报错重启，然后就无限卡win LOGO，想重做系统发现ssd无法格式化，无法分区，里面的数据也没法删除。最后无耐，查资料，看论坛。最后，买了个飚王SSK HE-V300移动硬盘盒，接上去后好容易量产成功了，我的LONGSYS 64G M6固态硬盘绿盘满血复活，实属不易，网络上的量产资料的确很少，特地分享出来。（量产工具在此文章后下载）
用开卡工具重生SSD，SM2246XT一步一步开卡成功教程
热门推荐
得得得的博客
08-30 2万+
下图中左框中是SSD的名称，好像随便输入，刚开始我没输，默认的，结果识别出来的不是三星，然后我又重新来了一遍写上三星，估计写什么都行，软件不同，有的就不能读，能用就行，没开卡之前，好像写的是三星PM380，MLC的！故障现象：不能进系统，用U盘从PE进入，过程很慢，卡住，进不了PE，直接拆下硬盘，用硬盘盒连接电脑，能识别，发现C盘还已经标红，D盘正常，还不错，文件都在，直接拷贝出来！进入编辑状态，点4，自动识别颗粒(Flash)，提示让你选择正确的类型，反正不懂，我就挨个试的。密码是两个空格，点OK。...
量产SM2246XT H AA主控固态硬盘，SM2246EN、SM2256开卡参考步骤，台电SD128GBS550拆机及开卡工具
zhufeizaza的博客
02-22 830
​先从量产部落找了一个对应固态主控和闪存颗粒的开卡软件，版本是MPP0920A_DBP0715_FWP0921A，在此感谢量产部落。
用JMS578转接板开卡PS3111主控pSLC模式，带固件下载
得得得的博客
07-18 3438
如果不设置自定义容量，也能开出一个16G的盘，但是这个盘的性能就非常诡异了，跑圈前8G跟pSLC差不多，后半段写入速度3-11M剧烈波动，平均值远低于直写时的15M。既然是要开成pSLC，那就需要全部开成SLCCache，这里改为8和8388608，实测改得超过这个数值也可以。四比一，应该是默认按照QLC的比例来计算的。PS3111开pSLC还是挺蛋疼的，还是SM2246EN简单。，MLC即为二分之一容量，TLC三分之一，QLC四分之一。，这里的选项达不到所需的量，这里选20G只为。...
gbs
Peter的专栏
10-11 3183
一 Building with GBS Locally The build sub-command builds RPM packages locally: $ gbs build -R repository -A ARCH [options] [package git dir] The [package git dir] option is optional. If not speci
固态硬盘开卡软件_使用8颗128GB MLC颗粒DIY一块SATA固态硬盘读写速度达510MB/400MB...
weixin_39556853的博客
12-12 4018
芯片出来有一段时间了，论坛上还没有看见有人发有关这个芯片的信息，今天自己来发一帖来聊聊感受，主角SM2246XT G AA主控板、闪迪15131板子来源X鱼购买的坏固态硬盘(此款板子支持自己更改成2246EN，需要补上3.3V缓存电源ic、电感、缓存、2246XT G AA更换成2246EN G AA)芯片来源X宝方老板家购买，全新SSD拆机芯片，东芝0DFK同款ID先拆下原硬盘上的8粒海力士芯片...
win10红警2黑屏_win10系统如何通过U盘安装系统呢？
weixin_39675178的博客
11-08 324
大家好，我是小白一键重装软件的客服。win10系统如何通过U盘安装系统呢？很多用户问到的就是使用U盘给电脑安装win10系统了，那么如果您电脑能够正常使用，小白建议您选择在线安装的哦，不仅安全而且方便简单，如果您的电脑无法正常开机、黑屏等现象，小白建议您继续往下看。说到电脑无法开机、黑屏、无法进系统等现象，请不要着急！小白系统提供了免费的人工技术客服为您解答，说不定很快变成装机大神了哦！第一步：安...
0817a
always007的博客
08-17 1587
https://zhidao.baidu.com/question/1302230504869242619.html
Python基础语法
09-20
### 回答1： Python 是一种高级编程语言，具有简洁易读的语法。下面是 Python 的一些基础语法： 1. 变量：在 Python 中，可以使用「=」符号来定义变量。 2. 数据类型：Python 支持多种数据类型，如整型、浮点型、字符串和列表等。 3. 运算符：Python 支持常见的数学运算符，如加减乘除和模运算等。 4. 控制结构：Python 支持常见的控制结构，如 if-elif-else、for 和 while 循环等。 5. 函数：在 Python 中，可以使用 def 关键字来定义函数，并使用 return 语句返回值。 6. 模块：可以使用 import 语句来导入 Python 模块，从而使用该模块中的函数和变量。 这只是 Python 语言的一个简单概述，如果需要深入了解，可以查阅相关资料或书籍。 ### 回答2： Python是一种高级编程语言，具有简单易学、可读性强的特点。它有许多基础语法规则，下面我将简单介绍一些。 首先，Python是一种解释型语言，可以直接执行代码而无需编译。我们可以使用Python解释器来执行Python程序。 Python的语句可以通过缩进来进行代码块的标识，这是Python语法的一个重要特点。通常情况下，使用四个空格来进行缩进，而不是制表符。 Python使用#符号来注释代码，可以用来提供对代码的解释或者临时禁用一段代码。注释可以增加代码的可读性。 Python有多种基本数据类型，常见的包括整数、浮点数、字符串、布尔值等。可以使用变量来存储和操作这些数据类型。 Python提供了一些基本的算术运算符，如加、减、乘、除、取余等。还有一些比较运算符，如大于、小于、等于等。 Python还提供了一些常用的控制结构，如条件语句、循环语句。条件语句可以根据条件的真假执行不同的代码块，循环语句可以重复执行一段代码。 Python还支持函数的定义和调用，函数可以封装一段特定的代码逻辑，通过调用函数来执行这段逻辑。函数可以接受参数和返回值。 除了内置的基本数据类型和函数，Python还提供了许多标准库和第三方库来扩展功能。可以使用import语句引入这些库，并使用库中的函数和类来完成各种任务。 以上只是对Python基础语法的简单介绍，Python是一门非常强大的语言，还有很多更复杂的语法和功能等待你去探索和学习。 ### 回答3： Python基础语法是指Python编程语言中最基本的语法规则和语法结构。它包括变量声明、数据类型、运算符、控制语句和函数定义等。下面我将详细介绍Python基础语法的几个主要方面。 首先是变量声明。在Python中，无需明确声明变量的类型，我们可以直接给变量赋值。例如，可以使用等号将一个值赋给一个变量，如x=5，表示将值5赋给变量x。在Python中变量的类型是根据赋给它的值来自动确定的。 其次是数据类型。Python中常见的数据类型包括整数、浮点数、字符串、列表、元组和字典等。整数用来表示整数值，浮点数用来表示小数值，字符串用来表示文字信息，列表用来存储一系列元素，元组用来存储一系列不可变的元素，字典用来存储键值对。 然后是运算符。Python中常用的运算符有算术运算符、赋值运算符、比较运算符、逻辑运算符和位运算符等。算术运算符用来进行数值计算，赋值运算符用来将值赋给一个变量，比较运算符用来比较两个值的大小，逻辑运算符用来进行逻辑判断，位运算符用来进行二进制操作。 接下来是控制语句。Python提供了if语句、for循环和while循环等控制语句，用来实现程序的流程控制。if语句用来进行条件判断，for循环用来遍历一个可迭代对象，while循环用来根据条件循环执行一段代码。 最后是函数定义。在Python中，可以使用def关键字来定义一个函数。函数是一段代码的封装，通过函数可以实现代码的复用。函数定义包括函数名、参数和函数体，函数可以有返回值也可以没有返回值。 综上所述，Python基础语法包括变量声明、数据类型、运算符、控制语句和函数定义等几个方面。掌握了这些基础语法，我们就可以开始编写简单的Python程序了。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值