从0学习python

1.Python（语法篇）

1.认识python

python是一门计算机编程语言，我们知道计算机所能理解的是二进制的代码，类似0101011101101010。但我们普通人要通过这些0、1来告诉计算机运行程序未免太痛苦了，所以人们发明了人类能看懂的高级语言，例如python。

2.解释器/编译器

计算机能运行的则是机器语言，所以我们用高级语言写完代码后需要将高级语言翻译为机器语言。在python中，我们用解释器来翻译代码。python具有很好的跨平台性，原因是python代码是以文本的方式储存，在每次运行时用解释器一行一行解释，这就省去了编译的过程。而编译器翻译代码则是一次翻译，之后要执行时就直接调用编译好的文件即可，所以可移植性差。

3.python的运行环境

下载python：www.python.org

集成开发环境：pycharm

4.第一个python程序

python文件是以.py结尾的。

第一个pyhton程序

print("Hello World") #输出Hello World

5.常见错误

1.NameError:名称错误

2.SyntaxError:语法错误

3.IndentationError:缩进错误

6.pycharm设置

项目：开发项目就是开发一个解决专门问题的软件，这个项目可以包含多个python文件。也就是说一个项目可以创建许多python文件

在pycharm中可以有多个项目

7.注释

顾名思义，注释是对代码的注解，想要看懂代码往往需要结合注释。

单行注释 #

print("hello world") #这是单行注释

多行注释 ’‘’ ‘’‘ 

'''这
是
多
行
注
释'''

8.变量

1.变量的定义

python规定，变量的命名只能以_、字母等开头，可以包含数字，区分大小写字母。不能用其他的特殊符号，在python中可以用中文作为变量名

你好 = "hello world"
print(你好)

2.数据类型及运算

1.字符串

1.字符串的定义

str = 'hello world'

就是变量名 = ”字符串的内容“     #这里是双引号、单引号都行

2.字符串的运算

1.下标运算

str = 'hello world'
print(str[0])
print(str[1])
print(str[2])
print(str[3])
print(str[4])
print(str[5])
print(str[6])
print(str[7])
print(str[8])
print(str[9])
print(str[10])
print(str[11]) #报错，超出范围

下标运算就是通过[](索引运算)来实现的，这里索引是从0开始的取出对应下标的值，索引有0到正，也有从-1到头的

print('hello world'[-1])
print('hello world'[-2])
print('hello world'[-3])
print('hello world'[-4])
print('hello world'[-5])
print('hello world'[-6])
print('hello world'[-7])
print('hello world'[-8])
print('hello world'[-9])
print('hello world'[-10])
print('hello world'[-11])

2.切片运算

顾名思义，切片运算就是对一个字符串的一部分进行取值。

#切片运算
str ='helloworld'
print(str[0:10:2]) 
'''切片操作，三个参数，
第一个是开始从0开始，
第二个是结束10，不过不包含这个10，
2是步长，表示取得是前一个索引加上这个步长2'''

除了标准写法外，还有一些省略写法，步长是1可以省[0:10]、第二个参数也可以省，这就表示一直到末尾结束[0::2] 、还有[:::]都省了，那就是用头开始，到最后结束，步长为1.就是怎么简单，不一一举例了.

3.拼接运算

str = 'hell0'
str1 = 'world'
print(str+str1)

直接用+来连接需要连接的字符串

函数：string.join()

Python中有join()和os.path.join()两个函数，具体作用如下：

 join()：连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
 os.path.join()：将多个路径组合后返回
函数说明

1、join()函数

语法：  'sep'.join(seq)

参数说明

sep：分隔符。可以为空
seq：要连接的元素序列、字符串、元组、字典
上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串

返回值：返回一个以分隔符sep连接各个元素后生成的字符串

a1 = [ 'hello' ,'good' , 'boy' , 'xiaoming']
print(' '.join(a1))
print(':'.join(a1))
#输出
hello good boy xiaoming
hello:good:boy:xiaoming

a2 = 'hello good boy xiaoming'
print(':'.join(a2))
#输出
h:e:l:l:o: :g:o:o:d: :b:o:y: :x:i:a:o:m:i:n:g

a3 = ('hello','good' , 'boy' , 'xiaoming')
print(':'.join(a3))
#输出
hello:good:boy:xiaoming

a4 = {'hello':1,'good': 2, 'boy': 3, 'xiaoming':4}
print(':'.join(a4))
#输出
hello:good:boy:xiaoming

2、os.path.join()函数

语法：  os.path.join(path1[,path2[,......]])

返回值：将多个路径组合后返回

注：第一个绝对路径之前的参数将被忽略

对序列进行操作（(分别使用’"与:"作为分隔符)

import os
a5 = os.path.join('/hello/','good /boy/','xiaoming')
print(a5)
#输出
/hello/good /boy/xiaoming

4.重复运算

str = 'hell0'
str1 = 'world'
print(str*3+str1*2)

重复运算就是用*来乘上需要的倍数即可，需要多少就乘多少

5.成员判断运算

str = 'hell0'
str1 = 'world'
print("w" in str,"o" in str,'e' in str)
print("e"in str1)

用 in 或者 not in来判断字符串是否属于其他字符串，这个判断是有顺序的，必须这个字符串中有一样的片段才能返回True 

6.比较运算

str = 'hello'
str1 = 'world'
print(str<str1)

字符串之间为什么能比较，每个字符都有一个编码，ASCII码，每个字符都是顺序的，w的顺序比要大，所以返回True，所以字符串比较大小是比第一个字符的大小，如果第一个字符大小相等，则比较第二个字符，一直比较出结果为止

关于ASCII码，查看ASCII码大小的函数是ord（），

print(ord('w'))
print(ord('h'))

相反的，函数chr（）可以用来查看该大小所对应的字符是谁

print(chr(111))
print(chr(114))

这只是字面上的比较，而对于某一存储单元的比较，用is 、is not来判断，对于同一个类来说，不同对象的属性可能在同一个数据单元中，这就是他们的地址一样，这是我们用is 、is not 来判断。

str = 'hello'
str1 = 'world'
print(id(str1))
print(id(str))
print(str1 is str)

用id（）来查看他们的地址

7.长度运算

str = "hello world"
print(len(str))

求字符串的长度用len（）来运算

8.排序运算

str = 'hello world'
print(sorted(str))

sorted函数将字符串内的字符进行排序，按照ASCII码表的大小，这里可以从大到小（reversed = True），也可以从小到大（可以省略,reversed = False），

str = 'hello world'
print(sorted(str,reverse = True))

 9.大小写变换

str = 'helloworld'
print(str)
print(str.capitalize())
print(str.upper())
print(str.lower())
print(str.swapcase())

s.capitalized（），这是首字母大写，upper（）全部大写，lower（）全部小写，swapcase（）这是大小写互换（大写变小写，小写变大写）。

有关字符串的运算操作还有很多，这里之后在做补充.

3.列表的定义

列表是一种有顺序的数据存储结构

list = [1,2,3,4,5]

列表名 = [ 存储的内容可以用逗号隔开]

4.列表的运算

1.增加元素

lst =[1,2,3,4,5,6,7,8,9]
lst1 = [1,234,532,123]
for i in lst1:
    lst.append(i)
print(lst)

append（）方法可以追加元素到列表的尾部，一次只能加一个元素。

lst =[1,2,3,4,5,6,7,8,9]
lst1 = [1,234,532,123]
lst.extend(lst1)
print(lst)

extend（）可以一次性将所有元素追加到尾部

lst =[1,2,3,4,5,6,7,8,9]
lst.insert(1,'a')
print(lst)

插入元素，insert（位置，元素）

2.删除元素

lst =[1,2,3,4,5,6,7,8,9]
lst.remove(2)
print(lst)

删除元素用remove（需要删除的元素），如果有多个，那么只删除第一个

3.替换元素

lst =[1,2,3,4,5,6,7,8,9]
lst[0] = 9
print(lst)

替换元素用  列表名[索引] = 新的元素内容，即可

4.查找元素

lst =[1,2,3,4,5,6,7,8,9]
print(lst[2])

查找元素，可以通过索引查找

这里关于列表省略了许多方法，其中很多与上述字符串的操作类似，比如切片等，后续可以补充

5.元组的定义

元组和列表相似，但是元组是不可变的序列类型，不能改变元组元素，所以元组中没有增、删、改操作。注意：当创建的元组中只有一个字符串类型的元素时，该元素后面必须要加一个逗号，否则 Python 解释器会将它视为字符串。而列表是可变的的序列

tuple(3,213,24,21)
tup = (3,213,24,21)
t1 = ('sda',) #元组中只有一个字符串元素，所以需要加上一个逗号

这两种方式都可以定义元组

6.元组的运算

1.元组的打包

在python中，允许一个变量同时等于多个值，多个值会被打包成元组。

tup1 = 1,23,22,32
print(tup1)

这就叫做元组的打包

2.元组的解包

x = 1,23,43
i,f,s = x
print(i,f,s)

3.删除元组

tup1 = (1,2,3)
del tup1 #删除了这个变量，也就是删除了这个元组

6.集合的定义

集合的特性是无序、互异、确定性，python也是如此

a = set(2,13,4)
b = {sda,12,23,231,1321}

两种定义

7.集合的运算

1.修改集合 

8.字典的定义

Python字典是另一种可变容器模型,可存储任意类型对象。如字符串、数字、元组等其他容器模型
因为字典是无序的所以不支持索引和切片。有这两种方法定义字典

dict = {"nane": "张三", "age": 20, "sex": "男"}
a = dict("nane": "张三", "age": 20, "sex": "男")

9.字典的运算

1.修改字典

# 定义一个字典
dict = {"nane": "张三", "age": 20, "sex": "男"}
# 增加元素
dict["score"] = 100
print(dict)
# 定义一个字典
dict = {"name": "张三", "age": 20, "sex": "男"}
#删除元素
del dict["name"]
print(dict)
# 定义一个字典
dict = {"name": "张三", "age": 20, "sex": "男"}
#查找元素
value=dict["sex"]
print(value)
# 定义一个字典
dict = {"name": "张三", "age": 20, "sex": "男"}
#修改元素
dict["name"]="李四"
print(dict)
#清空字典
dict.clear()
print(dict)

 3.结构化程序设计与模块化程序设计

 1.结构化程序设计

1.print(内容，end ，sep= )函数，有三种参数。

print(1,23,4,end = 'good',sep = ';')

end是以什么为结尾，sep是以什么为分割。

2.input（）函数，输入

a = input("plese input your number：")
print(a)

3.分支语句

4.循环语句

2.python（算法篇）

1.数据结构与算法

数据结构分为逻辑结构和存储结构

逻辑结构主要为：一对一、一对多，多对一，多对多和互不关联，即集合、树、图、线性。

存储结构主要有：顺序存储和链式存储

算法要满足5个必要条件：输入、输出、有穷性、确定性、可行性。

2.复杂度

1.时间复杂度：T（n）=O（f（n）），指的是该算法所需要的运行时间

2.空间复杂度:  S（n）=O（f（n）），指的是该算法所需要的空间

3.抽象数据类型

格式：

ADT 抽象数据类型名

Data   

        数据元素之间逻辑关系的定义

Operation

        操作

endADT

举例：

ADT List：
   List(self)           #创建一个新表
   is_empty(self)       #判断self是否是一个空表
   len(self)            #返回表长度
   prepend(self,elem)   #在表头插入元素
   append(self,elem)    #在表尾加入元素
   insert(self,elem,i)  #在表的位置i处插入元素
   del_first(self)      #删除第一个元素
   def_last(self)       #删除最后一个元素
   del(self,i)          #删除第I个元素
   search(self,elem)    #查找元素在表中第一次出现的位置
   forall(self,op)      #对表元素的遍历操作，op操作