Python基础入门

一：

1.任何语言都躲不过hello world保平安

print("hello world!")　　#直接输出

也可以：

s = "hello world!"　　#赋值s为字符串"hello world"
print(s)　　　　　　　　#输出s

二：Python对象类型

#python相比于c和c++等底层语言就是内置的对象多了，往往不需要自己动手实现，而是直接调用。

2-1:内置对象

2-1-1：数字

2-1-2：字符串

2-1-3：列表

2-1-4：字典

2-1-5：元组

2-1-6：文件

2-1-7：集合

2-1-8：其它类型

#这里列出来的并不完整，python处理的每样东西都是对象

#python是动态类型的，它会自动跟踪判断你的变量类型而不是寻找定义

#python是强类型的，只能对一个对象做适合该类型有效的操作

2-1-1：数字

数字类型包括整数、浮点数（即有小数的数）以及有虚部的复数等等，

能够进行 　　加法（+）、减法（-）、乘法（*）、乘方（**）、真除法（）以及假除法（\）等运算。

python还有数学模块math，可以使用import math语句导入。

到现在可以将python当成简单的计算器来使用。

#这种形式看作是对象的代码形式repr
520+1314        #计算加法
31*12              #计算乘法
2**3                #2的3次方

#下面这种形式看作用户的友好形式str
print(2*3.14)

import math
math.pi　　　　#将会输出Pi的值

import random
random.random()　　#会产生一个随机数
random.choice([1,2,3,4])　　#会在四个数中随意选择一个

2-1-2：字符串

字符串严格来说就是单个字符的字符串的序列。

作为一个序列，字符串可以有以下的操作。

"""字符串操作例子"""
s = “spam”    #定义一个四个字符的字符串,下标从0开始
len（s）         #len可以获得字符串的长度
s[0]               #可以获得字符串第一个元素的值
s[1]              #可以获得字符串第二个元素的值
          
s[-1]            #反向索引，获取最后一个字符的值

#序列也支持分片（slice）操作，即获取字符串任意一部分子字符串
s[1:3] 　　　　　　 #将获得第2和第3个字符组成的字符串"pa"，也就是下标从1到2，而不是3
s[:3] 　　　　　　　#"Spa"
s[0:3]　　　　　　　#"Spa"
s[:-1]　　　　　　　#除了最后一个，"Spa"
s[:]　　　　　　　　#"Spam",拷贝整个字符串，在以后的列表序列中这种操作很管用

最后，字符串也支持加号合并（两个字符串合成新的字符串），或者乘号（*）字符串重复成新的字符串。

不可变性：　之前的每一次操作原字符串都是被变成新的字符串类型返回作为结果，因为python中字符串具有不可变性。

　　　　　　因此，不能对字符串某一个位置进行赋值改变它的值。

但是我们可以对同一个变量名赋值多次，python会清理用旧的对象。

上面的操作对任意的序列（列表、元组等）都可以实现，下面看看字符串独特的操作（对象的函数）

"""部分字符串的独特操作"""
s = "Spam"　　　　#建立一个字符串对象
s.find('am')　　  #find函数，会返回找到第一次寻找到字符或字符串的下标位置，找不到返回-1
s.replace("pa","xyz")　　#将整个字符串中的"pa"改成"xyz"

s = 'aaa,bbb,ccc,ddd'　　#重新赋值s
s.split(',')　　　　　　　#会返回根据 逗号','分割的列表 ['aaa','bbb','ccc','ddd']

除此之外，字符串还可以改变大小写、判断是字符还是数字、去掉字符串后的空格字符等操作。

字符串还支持一种高级替代操作，用%s替代字符串：

'%s,eggs,and %s' %('spam','SPAM!')　　#会得到 'spam,eggs,and SPAM!'

这些只是一部分，要想了解更多，可以使用python的dir（）函数：

print("dir(s)")　　　　#会返回一个str属性和可操作函数的列表

 当我们通过dir（）看到各个函数后，可以调用help函数查看它的功能：

help（s.replace）

编写字符串的其它方法：

msg = """aaaaaa
bbbbb'''BBBBBB""casa'ccccc
ccacascsa"""            #包括在三个引号中，可以用于多行字符串

msg = "tom's"        #包括在双引号和单引号中是一样的

"""还可以使用转义字符"""
s = "A
B
C"　　#
是换行符，还有	是制表符等

模式匹配：

字符串对象的方法能够支持基于模式的文本处理，需要导入一个名为re的模块。

2-1-3 列表：

列表对象是python最通用的序列，是一个任意类型的对象的位置相关的有序集合，也就是对顺序有要求的集合。列表的大小可以修改。

对列表也能进行像对字符串那样的序列操作，比如利用下标访问某个列表元素，列表切片等等。

list = [123,'spam',1.23]　　　　#列表的初始化用方括号
list[0]　　　　　　　　　　　　　　#123
list[:2]　　　　　　　　　　　　　 #[123,'spam']

列表类型特定的操作：

python的列表与其它语言的数组有点相似，但是它不限定元素的类型，也不限制列表的大小。

#列表常用插入删除算长度操作
animals.append("mouses")  #在末尾插入
animals.insert(0,"rabits")  #在任意位置插入
print(animals)

del animals[0] #删除任意位置元素
animals.pop() #弹出最后的元素，可以把列表看作栈，弹出栈顶的元素
print(animals)
#pop()也可以弹出任意位置的元素，使用方法例如pop（index）

#sort永久排序，字母从小到大，sort(reverse=true) ,字母从大到小
#sorted是临时排序，原本的序列不会变，可以print(sorted(animals))

边界检查 ：

超过列表的长度执行赋值或者删除操作，会引发error，就跟数组越界一个原理。

嵌套：

python核心数据类型支持任意的嵌套，比如列表中嵌套列表（与其它语言多维数组类似），或者在列表中嵌套字典（后面会说），或者在字典中嵌套列表。

num = [ [1,2,3],
        [4,5,6],
        [7,8,9] ]    #可看做一个3x3的二维数组
print(num[1][1])　　　#会得到5
print(num[1])　　　　　#会得到[4,5,6]

列表解析：

列表解析就是取自集合的概念，对序列的每一项通过一个运算形成一个新的列表。

num = [ [1,2,3],
        [4,5,6],
        [7,8,9] ]    #可看做一个3x3的二维数组

cols = [row[1] for row in num]  #列表解析　，这个例子可理解为对num里每个元素，取下标为1的元素
print(cols)　　　　　　　　　　　　 #得到[2,5,8]　　

cols = [row[1] for row in num if row[1]%2==0]　　#有判断的列表解析
print(cols)　　　　#得到符合条件并且解析的 [2,8]

这种矩阵结构适用于小规模的任务，python有一个数值扩展包，例如开源的NumPy系统，有更高效的方法储存处理大型矩阵。

Python3中，解析语法也可以用来创建字典和集合。

2-1-4 字典：

字典不是序列，而是一种映射，key-value结构，由键映射到值（可以类比哈希表），是python核心对象集合中唯一的一种映射类型。

映射操作 ：

作为常量编写时，字典编写在大括号中，并包含一系列的 “键 : 值” 对，要是一些元素相关联时（例如某物的某属性），字典是很有用的。

#字典 (可以类比图->哈希表->键对应值、使用花括号)
menu = {'chicken':15} #一个元素的字典，也可以创建空字典{}然后逐个添加元素
menu['duck'] = 13
menu['fish'] = 10

print(menu) #显示字典
print(menu['fish']) #查找键值

del menu['duck'] #删除键-值对,永远删除
print(menu)

#遍历字典
user = {
    'username' : 'shl',
    'first' :'song',
    'last' : 'dragon',
}
#设置两个变量key和value
for key,value in user.items():  
    print("Key: " + key)
    print("Value: "+ value)#循环输出键值(同理可以遍历value值)，由此推出可以通过 if key in user.keys: 判断一个值是否在键中 
for key in user.keys():
    print(key)

for value in user.values():
    print(value)

#可以在字典中嵌套字典、字典中嵌套列表、列表中存放多个字典

重访嵌套：

若一个人又first name、last name都属于name，有多个工作jobs，还有姓名，这样可以写成下面这种嵌套模式：

msg = {    'name' :{ 'first' : 'Song','last':'Dragon'},
                'jobs' : ['Teacher','engineer',
                'age' : 20 }
#上面的字典里嵌套了字典和列表，可以对该列表和字典执行各自正常的操作例如增删查改等。

这里体现了python核心数据的灵活性。

在c和c++等底层语言中，当我们不在需要一个对象时，需要小心的释放掉它们的空间，但是python会自动在最后一次引用对象时清理掉它的空间。

2-1-5 元组：

元组长得和列表很像，但是它不可以修改，使用（）括住。元组也能支持任意类型、嵌套以及常见的序列操作。

元组有它独特的方法，但是不如列表多：

T = (1,2,3,4)　　#创建一个元组
T.count(4)　　#返回4出现的次数
T.index(4)　　#返回4出现的下标

2-1-6 文件：

文件对象是Python访问外部文件的接口，要创建一个文件对象，要调用内置的open函数以字符串的形式传递外部的文件名以及一个处理模式类型的字符串。

f = open('data.txt','w')        #w是输入模式，写文件
f.write('Hello')　　
f.write('World')
f.close()

f = open('data.txt')　　　　#现在是默认r模式，输出，读文件
s = f.read()　　　　　　　　　#读取文件
print(s)

还可以使用with open打开文件，文件不使用时会自动关闭：

with open('2.txt') as file_object1:
    #直接输出文本
    contents = file_object1.read()
    print(contents)            #当文件被打开读取一次后就会被关掉
    #逐行输出
    for line in file_object1:
        print(line)
    #先存到列表再输出
    lines = file_object1.readlines()
    for line in lines:
        print(line)

"""将文本输出到txt文件中"""
#会把原文件的内容清空，再写入新的内容
file_name = "2.txt"
with open(file_name,'w') as write_file:
    write_file.write("I love python.
")
    write_file.write("I love you too.
")

#附加文件模式，输入的不会覆盖原有的内容
with open(file_name,'a') as write_file:     # a是附加模式
    write_file.write("I love you so much
")
    write_file.write("The moon is very beautiful tonight
")

2-1-7 集合：

集合像无值的字典的键，不可变对象的无序集合，通过调用set实现。

X = set('spam') 
print(X)　　#{'a','p','s','m'}

2-1-8 其他类型：

例如布尔值，

True or False

占位对象符None：（通常用来初始化名字和对象）

L = [None]*100    #100个None的列表

三 函数：为了避免重复的去写一些相同的代码，就把某一个功能写成函数，可以多次利用。

#函数 (注意返回值，参数格式)
#函数是拥有名字的、执行一个功能的、可以被多次利用的一个代码段，可以免去重复写一段代码的臃肿

#一个简单例子
def sayHello():             #函数的定义用def
    """这是函数解释文档字符串：显示简单的问候语"""
    print("hello world")    #函数的功能实现 

sayHello()  #调用函数，会输出hello world

#带参数的函数
def talk_to(username):      #username 是形参，函数调用完毕地址就会被回收
    """显示对username问好"""
    print("Hello, "+username.title()+"!")

talk_to('judy') #'judy'是传递的实参
 
#传递参数的方法：1.位置实参 2.关键字实参
"""位置实参，传递的实参和形参的位置要一致""""""关键字实参，需要清楚指出函数中调用各个值的用途"""

def describe_pet(animal_type,pet_name):             #函数形参可以设置默认值 写成  def   describe_pet(animal_type = 'asf',pet_name = 'asfasf') 
    """显示宠物信息"""                               #当有默认值而调用时不输入实参，则形参使用默认值，否则形参为实参的值
    print("
I have a "+animal_type +".")
    print("My "+animal_type+"'s name is "+pet_name.title()+".")
#不同的传参方式调用这个函数  
describe_pet('harry','hamster') #位置实参
describe_pet(pet_name = 'hamster1',animal_type = 'harry1')  #关键字实参,此时顺序不重要

#返回值,与大多数语言一样使用return返回
def get_fullname(first_name = 'song',midle_name = '',last_name = 'dragon'): #midle_name是空字符串，是可选的 
    return first_name + " " + last_name         #直接返回字符串加起来的全名字符串

full_name = get_fullname()  #因为返回的是字符串，所以要用一个字符串变量承接这个值，就是把返回值赋给这个变量
print(full_name)

#也可以返回一个字典
def get_fullname1(first_name='song',midle_name='',last_name='dragon'): #midle_name是空字符串，是可选的 
    full_name1 = {'first_name':'song','last_name':'dragon'}
    return full_name1

fullname = get_fullname1()  #这里懒得输入，直接调用默认参数
print(fullname)

#同理也可以修改传递列表,用打印模具当实例
def print_model(unprinted_model,printed_model):
    while unprinted_model:      #使用while循环确保全部都打印后退出
        """打印模具"""
        model = unprinted_model.pop()
        print("It is printing "+model+" now!")
        printed_model.append(model)

def show_model(printed_model):
    """输出打印完的模具"""
    print(printed_model)

unprinted_model = ['a','b','c']
printed_model = []
print_model(unprinted_model,printed_model)
show_model(printed_model)

#如果想要传递过来的列表修改实参不受影响，可以使用切片
#则原函数调用改成   
unprinted_model1 = ['a','b','c']
printed_model1 = []
print_model(unprinted_model1[:],printed_model1)
print(unprinted_model1) #发现输出仍有原先的列表

#python可以不知道数量的情况下传递实参
def show(*items):
    """输出所选"""
    for item in items:
        print(item)
#以字符串做示例，其实元祖和列表和字典也都可以这样传递
show('aa','bb','cc')    #可以处理三个值
show('aa')              #也可以处理一个值

#有未知数量的键对值的参数
def show_items(**item):
    """将未知数量的键对值放进字典再返回"""
    items = {}  #新建空字典
    for key,value in item.items():
        items[key] = value
    return items

items = show_items(location = 'guangdong',position = 'yes')                 #两个键值对
print(items)
items = show_items(location = 'guangdong',position = 'no',date = '11th')    #三个键值对
print(items)

#将函数存在模块中
#导入xxx.py的xxx就可以导入该py文件下所有函数  格式:import xxx
#或者导入 from xxx import function_name
#当导入的函数名字与当前文件中函数冲突,可以用 as 改名字,from xxx import function_name as another_name
"""
上面的调用方法调用函数时都要用xxx.function_name()调用
"""
#import xxx *  
# 用*号就可以不需要.来调用函数，因为所有的函数都相当于复制过来当前文件中

四 类：可以定义新的用户类型

#类（面向对象编程精髓）
#格式：大写字母开头
class Animal():
    def __init__(self,name,weight):     #_init_是默认的构造函数，self是类自身的引用,这里我给了name和weight两个动物的特征当类的属性
        self.name = name
        self.weight = weight
    
    def show(self): #类的函数叫做方法，括号里的是方法的参数，参数都要含有self并且放在第一位
        print("This is an animal, its name is "+self.name+".")
        print("Its weight is "+self.weight+".")

animal = Animal('peter','100kg')    #创造类的实例对象
animal.show()                       #对象调用方法

#继承，当一个类与其他类还有包含关系时，就像动物和小狗，小狗有动物的所有特征，并且有它自己的特征，可以用继承直接复用动物类的方法
class Dog(Animal):      #括号里放继承自哪个类，也叫超类(superclass)、父类.
    def __init__(self,name,weight):
        super().__init__(name,weight)  #调用父类的构造函数，注意没有self
        self.speed = 70
    def show(self):     #改写父类的show方法
        print("This is a dog, its name is "+self.name+".")
        print("Its weight is "+self.weight+".")
        print("Its speed is "+str(self.speed)+".")
dog = Dog('kity','123kg')
dog.show()

#关于类导入另一个文件
"""一个类也可以当别的类的属性，一个模板中可以储存多个类和函数"""
"""from Animal import Animal 可以在另一个文件中导入Animal这个类"""
"""可以导入整个模块再用点访问 module_name.class_name，也可以用*导入模块中所有类，但是这种容易引发命名方面的困惑"""

#python标准库
"""python本身带有一组模块，里面有很多写好的函数和类

五  用户输入、判断和while循环

#if (只看格式,除了esif ,in,not in,其它大致与其它相同,记住不要忘记‘：’)
#条件逻辑有 and,or 

nums = [1,2,3,4]

if 1 in nums:
    print("yes")
elif 2 in nums:
    print("this is all right")
else:
    print("no")

#用户输入和while循环
input输入默认字符串，要想获得其他类型如整数要进行类型转换,int()
message = input("please input what you want to do"+"
")  #VS Code的OUPUT输出台不能接受用户的输入，要在终端运行
print(message)

#while循环使用方法与其它的语言大致相同，同样拥有break直接跳出循环和continue从当前位置直接进入下一次循环
i = 1
while i < 10:
    print(i)
    i = i + 1