python3基本语法

 

　　python基本语法

　　

# python开始练习

print("我的第一个python程序!");  # 内容的打印

# 这是python的单行注释

'''
这是python的多行注释

'''

print("注释的测试!");


str = "如果语句太长,我们可以使用反斜\
杠来进行换行,但是在[], {}, 或 () 中的多行语句，不需要使用反斜杠(\)";
print(str);    


# python字符串有的写法多行可以使用'''或者"""包裹起来  字符串有两种索引方式,从左往右是从0开始的,从右往左,是从-1开始的
str1 = '''你好
,这是一个段落,如果包裹起来,输出方式就会按照里面的内容原样输入,也会进行换行.
''';
print(str1);  


age=input("请输入您的年龄一旦按下enter键表示退出");  # 内容的输入 也就是从键盘进行输入  并进行赋值


# python对缩进的语法特别严格,省略了java中的大括号,并且不需要编译,是一种面向对象解释型的语言,缩进为4个空格符,不是制表符
print("==========================================================");
print("字符串的一些用法");
str2 = "你好,我是python";
print(str2)                 # 输出字符串
print(str2[0:-1])           # 输出第一个到倒数第二个的所有字符
print(str2[0])              # 输出字符串第一个字符
print(str2[2:5])            # 输出从第三个开始到第五个的字符     左包含右不包含
print(str2[2:])             # 输出从第三个开始的后的所有字符
print(str2 * 2)             # 输出字符串两次
print(str2 + '你好')        # 连接字符串
print('hello\nrunoob')      # 使用反斜杠(\)+n转义特殊字符
print(r'hello\nrunoob')     # 在字符串前面添加一个 r，表示原始字符串，不会发生转义


print("不换行的操作时在后面加上end=\"\",用逗号隔开!!!!",end="");
print("不换行");

print("==========================================================");

　print("查看内存地址",id(12));
　print("查看有哪些方法",dir(str2));

# python if语句
print("==========================================================");
if True:
    print("if语句测试");
else:
    print("if语句为else的时候");

print("==========================================================");    

# python 数字类型有四种 整型 布尔类型 浮点型  复数

print("=================python导入模块几种写法===================");  

# 使用import 或者from ... import来导入相应的模块
# 将整个模块(somemodule)导入，格式为： import somemodule

# 从某个模块中导入某个函数,格式为： from somemodule import somefunction

# 从某个模块中导入多个函数,格式为： from somemodule import firstfunc, secondfunc, thirdfunc

# 将某个模块中的全部函数导入，格式为： from somemodule import *

print("==========================================================");  

print("python语句已经结束");

 

# python的基本数据类型

print("------------多个变量的赋值---------------------")

a,b,c = 1,2,"你好"; # 将1,2 分别赋值给a,b ,c = "你好"

print("===============================================")


print("------------标准的数据类型---------------------")

'''
不可变数据类型: Number 数字类型  String 字符串   Tuple 元组  

可变数据类型: List 列表  Set 集合  Dictionary 字典类型


可以使用print(type(1)) 查看数据类型

type()不会认为子类是一种父类类型。
isinstance()会认为子类是一种父类类型。

'''
print("数据类型的查看",type("你好"));
print(isinstance(a, int));  # 数据类型的判断

print("------------列表的相关规则---------------------")

# 列表就相当于java中的数组,

list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist = [123, 'runoob']
 
print (list)            # 输出完整列表
print (list[0])         # 输出列表第一个元素
print (list[1:3])       # 从第二个开始输出到第三个元素
print (list[2:])        # 输出从第三个元素开始的所有元素
print (tinylist * 2)    # 输出两次列表
print (list + tinylist) # 连接列表
print (list[0:3:2])     # 从第二个开始输出到第三个元素,步长为2,间隔一个位置来取数据,就是在这个之间,间隔一个位置来取数据

print("===============================================")


print("------------元组的相关规则---------------------")

# 元组和列表的区别是,元组不能进行改变  就是不能给元组进行赋值
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2  )
tinytuple = (123, 'runoob')
 
print (tuple)             # 输出完整元组
print (tuple[0])          # 输出元组的第一个元素
print (tuple[1:3])        # 输出从第二个元素开始到第三个元素
print (tuple[2:])         # 输出从第三个元素开始的所有元素
print (tinytuple * 2)     # 输出两次元组
print (tuple + tinytuple) # 连接元组

print("===============================================")



print("------------集合的相关规则---------------------")

# 可以进行基本功能的操作,去重等等
student = {'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}
 
print(student)   # 输出集合，重复的元素被自动去掉
 
# 成员测试
if 'Rose' in student :
    print('Rose 在集合中')
else :
    print('Rose 不在集合中')
 
 
# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')
 
print(a)
 
print(a - b)     # a 和 b 的差集
 
print(a | b)     # a 和 b 的并集
 
print(a & b)     # a 和 b 的交集
 
print(a ^ b)     # a 和 b 中不同时存在的元素

print("===============================================")


print("------------字典的相关规则---------------------")

# 字典就相当于java中的map集合
dict = {}
dict['one'] = "1 - 菜鸟教程"
dict[2]     = "2 - 菜鸟工具"
 
tinydict = {'name': 'runoob','code':1, 'site': 'www.runoob.com'}
 
 
print (dict['one'])       # 输出键为 'one' 的值
print (dict[2])           # 输出键为 2 的值
print (tinydict)          # 输出完整的字典
print (tinydict.keys())   # 输出所有键
print (tinydict.values()) # 输出所有值


print("===============================================")


print("**************************************************");
print("python程序已经结束!!!");

 

　　对象的使用

# python的笔记学习

# 创建一个初始的类
class Person:
    
    # 定义类属性
    count = 0
    
    def __init__(self,name,age):
        print("类的初始化,相当于java中的构造方法")
        self.name = name
        self.age = age
        Person.count += 1  # 定义创建了几个对象
 

#离上面空两行,然后调用当前这个类
person = Person("小明",12);    
print("%s今年%s岁了!!" %(person.name,person.age))  
 
print("Person对象创建了%s个对象!!" %Person.count)  
 
# 类中的属性如果为双下划线开头,则表示为私有属性,不能直接进行访问,和java中私有属性相同   
# 括号中可以进行继承,java只能单继承,但是python可以进行多继承,默认继承object
# 多继承就会涉及到如果父类都有相同的方法,应该执行哪个?
# 这个和继承的类顺序是有关系的   可以通过   类.__mro__ 进行查看   
class Person1(object):
    
    # 定义类属性
    count = 0
    
    def __new__(cls,*args,**kwargs):   # 另外两个参数  不定长参数      关键字参数 如 age=12
        print("创建的时候,被执行!!!!")
        return object.__new__(cls)
    
    def __init__(self,name,age):
        print("类的初始化,相当于java中的构造方法")
        self.__name = name    # 私有属性
        self.__age = age   

    @classmethod   # 类方法
    def get_count(cls):   # cls 代表着是类
        return cls.count
        
    @staticmethod  # 静态方法  跟类没有任何关系的方法,可以使用静态方法
    def get_static():
        print("静态方法!!")
        return "我是静态方法"
        
    def __del__(self):
        print("person 对象被销毁了!!!")    
    
            
print("类方法---->",Person1.get_count()) 
# 类方法,就是和类相关的方法就叫做类方法 用@classmethod  
print("静态方法----->",Person1.get_static())

# 销毁操作的测试,在当前程序结束的时候,进行销毁   当对象赋值为None 的时候也会执行此操作 
Person1("小花",22)

# 内置方法

# __str__(self):  将对象转化为字符串,并将字符串进行返回   类的打印如果有这个方法   和__repr__ 方法随便使用
# __class__   获取对象
# C.__mro__   继承方法解析对象顺序
# __len__(self): 重写长度
# __call__(self,*args,**kwargs):  a1 = Person();  相当于调用 a1()    


# 构造函数(就是对象创建的时候给对象进行初始化,相当于java中的构造方法)和析构函数(对象销毁的时候调用的方法,做相关的清理工作和资源的释放)

# __new__ :创建对象的函数,接受参数为cls,用于创建对象的时候执行,并返回当前对象
# __init__: 对象的初始化
# __del__: 当一个对象从内存中被销毁的时候执行该方法
# 执行顺序是从上往下


print("涉及到多继承的方法解析顺序问题--->",Person.__mro__)


print("本次程序结束!","*"*50)

 　　模块的导入

    
# python中模块的引用

# 在python中一个py文件,就是一个模块,模块名称就是文件名称   命名参考全部用小写,或者下划线隔开

# 模块方便维护,提高代码的复用性  避免相同的函数名称等等

# 比如 user.py 模块名称就是user



# 随机生成一个数据
import random    # 可以使用as进行别名


# 方式二
# from random import randint     如果导入多个,直接使用逗号隔开   直接使用方法民称  如 randint(1,10)  



num = random.randint(1,10)
print("随机数的调用",num)


# 也可以导入自己定义的模块

# *args 不定长数据,相当于元组


# 调用其他模块



print("本程序结束","*"*50)

　　测试模块

# 作为一个测试模块


#  声明导入的方法名称 只对定义作为 * 导入的方法有效果
__all__ = ["fun1","add"]

def fun1():
    print("我是测试模块")
    

def add(*args):
    """   计算总和      """
    values = 0
    for item in args:
        values += item
    return values    
        
        
# 有时候为了测试 需要执行
# 为了防止导入执行测试我们需要放入到

# 当作为主程序是__name__ 为__main__   ,当为模块导入时,__name__ 为模块名称

# 所以测试的时候都放入到这里
if __name__ == "__main__":
    add_num = add(1,2,3,4,5)
    print(add_num)        

 　　包的知识

# ======================包的管理===============================

# 当我们有很多的模块的时候,我们可以进行分类管理,方便模块的维护,  一个目录作为一个包,包中必须要有一个__init__.py 文件

# 上面的作用是: 用来初始化模块(里面可以有代码), 声明一个包的结构  使用方式是 包名.模块名称

# 方式一  包名.模块名称
# 方式二 from 包名 import 模块名称

# 模块名称不能以数字开头,编译的时候是没有问题的,但是导包会出现invalid token错误


# ============================模块的发布==============================

# 第一步在最外层模块创建一个setup.py 文件

from distutils.core import setup
setup(
    name='util',       # 包名
    version='1.0',
    author='sxmd',
    author_email='',
    url='http://',
    download_url='http://',
    description='util module',
    py_modules=['util.a','util.b']   # 导入哪些模块
)

# 第二步构建模块
python setup.py build

# 第三步 生成发布压缩包   一般打包打包成*.tar.gz
python setup.py sdist


# ===============================模块的安装方式==========================

模块名称.__file__   模块的路径(模块要使用python写的)


pip 包的安装

如果不清楚 pip -- help

pip install 包名