小白IT：Python 入门基础

一 Python 基础

##基本语法构造

python：蟒蛇，创立者：Guido van Rossum，2002年更新了python2.x版本，2008年更新了python3.x版本

python语言应用方向

• 云计算: 云计算最火的语言， 典型应用OpenStack
• WEB开发: 众多优秀的WEB框架，众多大型网站均为Python开发，Youtube, Dropbox, 豆瓣。。。， 典型WEB框架有Django
• 科学运算、人工智能: 典型库NumPy, SciPy, Matplotlib, Enthought librarys,pandas
• 系统运维: 运维人员必备语言
• 金融：量化交易，金融分析，在金融工程领域，Python不但在用，且用的最多，而且重要性逐年提高。原因：作为动态语言的Python，语言结构清晰简单，库丰富，成熟稳定，科学计算和统计分析都很牛逼，生产效率远远高于c,c++,java,尤其擅长策略回测
• 图形GUI: PyQT, WxPython,TkInte

编译型和解释型

• 编译型

优点：编译器一般会有预编译的过程对代码进行优化。因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率高。可以脱离语言环境独立运行。

缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编译不同的可执行文件。

• 解释型

优点：有良好的平台兼容性，在任何环境中都可以运行，前提是安装了解释器（虚拟机）。灵活，修改代码的时候直接修改就可以，可以快速部署，不用停机维护。

缺点：每次运行的时候都要解释一遍，性能上不如编译型语言。

动态语言和静态语言

• 动态类型语言

动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。Python和Ruby就是一种典型的动态类型语言，其他的各种脚本语言如VBScript也多少属于动态类型语言。

• 静态类型语言

静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、JAVA等。

强类型定义语言和弱类型定义语言

• 强类型定义语言

强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。举个例子：如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。强类型定义语言是类型安全的语言。

• 弱类型定义语言

数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。强类型定义语言在速度上可能略逊色于弱类型定义语言，但是强类型定义语言带来的严谨性能够有效的避免许多错误。另外，“这门语言是不是动态语言”与“这门语言是否类型安全”之间是完全没有联系的！

python是一门动态解释性的弱类型定义语言

语法构造

python保留字/关键字

概念：被编程语言内部定义并保留使用的标识符，python语言中共33个保留字，也叫关键字

• and elif import return
• as else in try
• assert except is while
• break finally lambda with
• class for not yield
• continue from or
• def global pass
• del if raise

注释

程序中用作对代码和文件的解释说明，用于提高程序的可读性，不被执行

使用方法

1. 单行注释：# 被注释内容
2. 多行注释：’’‘被注释内容’’’，或者""“被注释内容”""

缩进

1. 语法的一部分，缩进不正确程序运行出错
2. 表达代码间包含和层次关系的唯一手段
3. 长度一致，程序一致即可，一般用4个空格或一个tab

输入函数input()，从控制台获得用户输入的函数，<变量> = input(<提示信息字符串>)

python2中的input输入的是什么类型，获取到的就是什么类型

username = input('请输入用户名:')

输出函数print(),以字符串形式向控制台输出结果的函数,print(<拟输出字符串或字符串变量>)

python3中的input获取到的都是字符串类型

print('hello world!')

算数运算符 arithmetic operator

• + - * /：加减乘除
• %：模运算，也就取余数
• //：商运算，取整数

%模运算的真正操作原理：

1. 用第一个数除以第二个数，得到最相近的两个商。取最小的数。
2. 用第一个数减去第二个数和第一步的到的数的乘积。

赋值运算符 assignment operator

• 基本赋值运算符：=
• 扩展的赋值运算符：+=、-=、*=、/=、%=

如 x += y <==> x = x+y

比较运算符 compare operator

• <：小于，用于可比较变量之间的比较
• >：大于，用于可比较变量之间的比较
• =：等于，用于变量的赋值
• !=：不等于，用于判断两个字符是不是一样的
• ==：等于等于，用于判断两个字符是不是一样的，

逻辑运算符 logic operator

python中只包含3中逻辑运算符：and、or、not

逻辑运算符的结果是什么类型

x or y if x is true, return x, else return y
 
x and y if x is true, return y, else return x

成员运算符

in 和 not in：判断某个元素是否属于某个范围内。

s = 'abcd'
print('a' in s) # True

基本数据类型

数字 int

概念：与数学中数字的定义一样。

在python3中支持的数字类型：

• int–整型
• float–浮点型
• bool–布尔型
• fractions–分数
• complex–复数

数字常用方法：

• type()用来判断某个值的类型

print(type(6))
---> int

• isinstance(a,类型名)：判断a是不是某个类型

print(isinstance(3,int))
---> True

字符串 str

凡是用单引号、双引号、三个单引号、三个双引号引起来的内容就是字符串。

字符串的特点：可哈希，也就是不可变数据类型。

字符串的索引：每个字符都有对应的号码，正向从0开始递增，逆向从-1开始递减。

切片：通过索引（切片）出来的内容都是字符串类型。切片的方式是一个前开后闭的范围
s = 'pythonisinteresting'

s1 = s[:6] # 从0开始可以省略不写
print(s1)  #python
s2 = s[6:9] #isi
print(s2)
s3 = s[:] # 从头取到尾
print(s3)
s4 = s[6:] # 从第六个i 开始取到最后
print(s4) #isinteresting


切片+步长方式

s = 'pythonisinteresting'

s5 = s[:5:2]
print(s5)

------ ------ ------ ------ ------ ------ ------ ------ ------ ------ ------
字符串的常用操作

	str.capitalize 首字母大写 **
  
s = 'taiBai'

s1 = s.capitalize()
print(s1)
print(s)
str.upper() 字符串大写     str.lower() 字符串小写
s = 'AbcD'

s1 = s.upper()
s2 = s.lower()
print(s1)
print(s2)

	str.center(长度，填充内容）把字符串以填充内容填充到指定长度
s = 'abc'

s3 = s.center(20, '*')
print(s3,',',len(s3))  ********abc********* , 20
             
	str.swapcase() 把字符串的字母大小写反转
s = 'taiBai'
s4 = s.swapcase()
# print(s4)
             
	str.strip() 去掉字符串两侧的空格,加参数去掉指定内容。
	str.lstrip() 去掉左侧空格，str.rstrip() 去掉右侧空格
s = '    alex\n'
s = '\talex\n'
# print(s)
s6 = s.strip()
print(s6)
             
	str.strip('xxxxxx')去掉指定内容
s = 'qw*awle@xyt@'
# 可设置去除的字符
s6 = s.strip('qyt@w*')
print(s6)
             
	str.split() 默认按照空格分隔，指定字符时，按照指定字符分隔，并将分隔后的元素放入一个列表---输入是列表
s = '武大 小潘 西门'
l = s.split()
print(l)

	str.split('字符')指定字符分割。---输入是列表
s = '武大,小潘,西门'
# l = s.split(',')
print(l)

	str.split('A',int)指定分割次数---输入是列表
s = '武大a小潘a西门'
rsplit() 从右边开始分割
print(s.split('a',1))
             
	连接符.join(iterable)输出str      注：操作列表时，列表里面的内容必须全部是字符串类型
l1 = ['wusir', 'alex', 'taibai']
s7 = ','.join(l1)
print(s7)  #wusir,alex,taibai 
             
	str.startswith() ***用作判断以什么为开头 可以切片。---输出True/False
	str.endswith()  ***用作判断是否以什么结束，可以切片 ---输出True/False
s = 'alextaibai'
s8 = s.startswith('a')
s9 = s.endswith('i)

print(s8,s9)  True True
                
	str.find ：通过元素获取其索引,找到第一个就返回,找不到会返回-1.
  跟(int)-find('a',int)表示计算整个str中第(int)个出现的索引
s = 'taibai'
s1 = s.find('a')
              
                
	str.index：通过元素获取其索引,找到第一个就返回，**找不到会报错**。 
  跟(int)-index('a',int)表示计算整个str中第(int)个出现的索引
s = 'taibai'
s1 = s.index('W')
print(s1)   #ValueError: substring not found  
                
	str.replace(old, new) 替换字符串中的元素
s = 'alex 是一个很nb的人，非常nb，太nb了'
s10 = s.replace('nb', 'sb')
s10 = s.replace('nb', 'sb', 2)
print(s10)
                
	isdigit()判断是不是数字组成
	isalpha()判断是不是字母组成

Bool 类型

python中用来表示逻辑运算结果的值，只有True和False两种。

不同数据类型和bool类型的对应关系

str —> bool 非空即True

数字 —> bool 除0为False外，其他都为True

列表 List

一种序列类型的数据，十分常用

特点：

• 使用[]或list()创建，逗号分隔
• 较字符串对比可以存储大量数据

列表的索引和切片

• list[m]：获取列表中索引为m的元素，返回的类型是元素的本身数据类型
• list[m:n:k]：返回一个列表，其中元素是根据步长获取的列表中的元素
• list[m:n]：返回一个列表，其中元素是列表中索引从m到n但不含n的元素
• list += lt：更新list，将lt元素增加到list中
• list1+list2=list3: list3 是list1&list2的列表打开结合所成新的列表

列表的增删改查

列表的增

1.append 单个追加到列表末尾
li.append('lulin')
li.append(['10', 2, '3'])

2.insert 插入，按照索引位置插入值
li.insert(1, 'lulin')

2.extend 追加可迭代对象，将可迭代对象拆分为单个元素添加至列表后面
li.extend('asdfn')
li.extend([1, 2, 5, 's'])
li.extend(11) 会报错，数字不可迭代。

列表的删

1 pop 按照索引删除，不指定索引会删除最后一个，最后会将删除的元素做为返回值返回
ret = li.pop(0)
print(ret)

2 remove 指定元素删除,如果元素有多个，只删除第一个元素,没有返回值
li.remove('self')

2 clear 清空列表,返回一个空列表，也就是原列表清空但没有删除，返回回来
li.clear()
print(li)

4 del 根据索引、切片（步长）、删除，或删除整个列表,在内存中清除此列表
del li[0]
del li[1:4:2]
del li

列表的改

1.改动某个索引元素
li[0] = 'nanshen'

2.按切片改动
li[:3] = 'abc'
li[:3] = 'asdfnlasnfd' # 说明切片改动类似可迭代改动，清空切片位置，添加元素个数不定，可多可少

3.安切片（步长）改动，切片长度与重新添加元素个数必须一一对应
li[1:4:2] = 'a' # 错误
li[1:4:2] = 'ab'
li[1:4:2] = [1, 2, 3] # 错误

列表的查

# 查
1 按照索引，按照切片（步长）查询
2 for循环
    for i in li:
        print(i)
print(li)

列表的其他操作方法

• list.sort() 将列表中的元素排序，根据ascii编码对应的数字排序

• list.reverse() 将列表中的元素反转，需要查看列表看反转结果

• list.index(x) 返回元素x在list中的索引，没有就报错

• list.count(x) 返回元素x在列表中出现的次数。

• list.copy() 返回一个列表的副本，浅拷贝

元组类型 tuple

概念：一种不可修改的序列类型

特点：

• 创建后不可修改
• 使用小括号或tuple()创建
• 可使用或不适用小括号

tu1 = (1, 'alex', [1,2,3], True)
# 可索引，切片
print(tu1[1])
print(tu1[:3])

# 元组只能查不能改
# 特点：元素的元素不能进行复制，如果元素是可变数据类型，可以修改该元素
# 索引，切片（步长） 查询
for i in tu1:
    print(i)

元组类型的操作：继承序列类型的所有通用操作

定义后无法修改，没有特殊操作

使用或不使用小括号

# 元组当真不能改么？？？
tu1 = (1, 'alex', [1,2,3], True, (1,2,3))

# 儿子不能改，孙子可能改。
tu1[2].append('太白')
tu1.append(666)
print(tu1)

使用场景

一般用于记录比较重要的不可修改的数据，如初始坐标扽等

字典类型 dict

字典概念

映射：一种键（索引）和值（数据）的对应，字典是映射的体现。

键值对：键是数据索引的扩展，字典是键值对的集合，键值对之间无序，采用大括号{}和dist()创建，键值对用":"表示。

表现形式：{<键1>:<值1>,<键2>:<值2>,…<键n>:<值n>}

字典的增删改查

字典的增加

dic = {
    'name': '太白金星',
    'age': 18,
    'hobby': 'wife',
}

1.有责修改，无则添加

dic['hight'] = 176
dic['age'] = 23
print(dic)

# 结果
dic = {
    'name': '太白金星',
    'age': 23,
    'hobby': 'wife',
    'height': 176,
}

2.有则不变，无则添加

# 原理：先查找键，如果字典中有，返回对应的值，如果不在，返回none，根据返回值，如果不为空，则不变，如果为空，在添加键值对
print(dic.setdefault(2, 5)) # 打印的结果为5，即setdefault会返回值。
dic.setdefault('weight')  # {'name': '太白金星', 'age': 18, 'hobby': 'wife', 'weight': None}
dic.setdefault('weight',160)  # {'name': '太白金星', 'age': 18, 'hobby': 'wife', 'weight': 160}
dic.setdefault('name','barry')  # {'name': '太白金星', 'age': 18, 'hobby': 'wife'}

字典的删除

dic = {
    'name': '太白金星',
    'age': 18,
    'hobby': 'wife',
}

1.pop按照键删除

ret = dic.pop('age')  # 按照键删除掉键值对
print(ret)
# dic.pop('age1')  # 没有报错
ret = dic.pop('age1', '没有此键')  # 设置两个参数，第二个参数是提示语 一般设置成None

print(ret)  # 没有此键
print(dic)  # {'name': '太白金星', 'hobby': 'wife'}

2.clear清空

dic.clear()
print(dic)  # {}

3.popitem()删除

3.6版本之后就是删除最后一个键值对

ret = dic.popitem()
print(ret)  # ('hobby', 'wife')
print(dic)  # {'name': '太白金星', 'age': 18}

4.del指定键删除

del dic['name']  # 按照键删除
print(dic)  # {'age': 18, 'hobby': 'wife'}
# del dic['name1']  # 键不存在报错，keyError
del dic  # 删除字典

字典的修改

dic = {
    'name': '太白金星',
    'age': 18,
    'hobby': 'wife',
}

1.指定键直接修改

dic['age'] = 30
print(dic)  # {'name': '太白金星', 'age': 30, 'hobby': 'wife'}

2.update()指定键值对修改，键存在则修改，键不存在则添加

dic.update(name="ryxiong")  # 键存在
print(dic)  # {'name': 'ryxiong', 'age': 18, 'hobby': 'wife'}

dic.update(gender="male")  # 键不存在
print(dic)  # {'name': 'ryxiong', 'age': 18, 'hobby': 'wife', 'gender': 'male'}

3.update()指定字典更新，有的键会覆盖，没有的键会添加。

dic = {"name": "jin", "age": 18, "sex": "male"}
dic2 = {"name": "alex", "weight": 75}
dic2.update(dic)
# 将dic里面的键值对覆盖添加到dic2中
print(dic)  # {'name': 'jin', 'age': 18, 'sex': 'male'}
print(dic2)  # {'name': 'jin', 'weight': 75, 'age': 18, 'sex': 'male'}

字典的查找

1.直接通过键查找

print(dic['age'])
print(dic['age1'])  # 没有报错

2.通过get方法查找

# 有的返回对应的值
print(dic.get('age'))  # 18
# 没有此键默认返回None
print(dic.get('age1'))
# 可以设置没有找到时返回的返回值
print(dic.get('age1', '没有此键'))

字典的其他操作方法

# dict.fromkeys(iter,x)
# 传入一个可迭代对象，将这个可迭代对象的每个元素当成字典的键，将后面的参数作为每个键的值，构建一个列表并返回。

dic = dic.fromkeys('adfa', 'ryxiong')
dic = dic.fromkeys('abcd,', [1,])
**判断键是否在字典里？**
py2 是 has_key('键')
py3 if key in 字典
	结果

文件读写操作

文件基础操作

# with open(filename, mode, encoding) as f:
#        f.read()  # 注意缩进

# 打开多个文件
with open(filename1, mode, encoding) as f1,\
    open(filename2, mode, encoding) as f2:

文件读操作

'''
读的方法
f = open(filename, mode, encoding)
1.全部读取
    f.read()
2.r只读模式下；r模式下，n单位为字符，rb模式下，n单位为字节
    f.read(n)
3.按行读取
    1.读取单行
        r.readline()
    2.读取多行，返回一个列表类型
        r.readlines()
    3.如果指定了一个非负数的参数，则返回指定大小的字符数，包括 "\n" 字符。
        r.readline(n)
4.循环读取：最优读法，每次在内存中只读取一行，读完转换后会释放内存。
    for line in f.readlines():
        print(line)
'''


f = open("file_read.txt", encoding='utf-8')

# 1.读取全部内容
data = f.read()

# 2.读取单行
data = f.readline()

# 3.读取多行，返回一个列表类型
data = f.readlines()

# 3.读取前多少行
data = f.readline(5)

print(data)

f.close()

文件写操作

'''
文件的写：
    写入方法：
         w：创建写模式：文件名不存在，则创建写；存在则清空内容在写入
         wb：以二进制的方式创建写入--列：图片
         w+:写读模式，可写可读
f = open(filename, mode, encoding)
'''


# w:创建写模式，文件名不存在，则创建写；存在则清空内容在写入
f = open('file_write.txt', 'w', encoding='utf8')

f.write('i am handsome!\n')
f.write('i am handsome!\n')
f.write('i am handsome!\n')
f.write('i am handsome!\n')

f.close()


'''

非字符内容的读取和复制

# 非字符内容的读取和复制
'''
# 以二进制方式读入非字符内容
f1 = open('bueaty.jpg', 'rb')
content = f1.read()
f1.close()

# 以二进制方式写入非字符内容
f2 = open('bueaty_copy.jpg', 'wb')
f2.write(content)
f2.close()

文件的追加操作

'''
文件的追加：
    追加写入方法：
         a：创建写模式：文件名不存在，则创建写；存在则清空内容在写入
         ab：以二进制的模式追加写入
         a+:可追加写，可读
f = open(filename, mode, encoding)
'''

data = 'asdfasdf'
lis = ['asd','sadf','adsf']
with open('file_write.txt','a',encoding='utf-8') as f:
    f.write(data)  # 在文件末追加写入
    f.writelines(lis)  # 在文件末写入多行

文件的其它操作方法

''
对文件句柄（数据流）的操作方法
f = open(filename, mode, encoding)

f.read(): 读取全部内容
f.readline(): 读取单行
f.readlines(): 读取多行

f.close()： 关闭文件
f.flush(): 刷新文件，更新改动内容

f.readable(): 判断文件是否可读
f.writable(): 判断文件是否可写
f.seekable(): 判断光标是否可指定

f.seek(n): 根据字节数指定当前光标位置
f.tell(): 获取当前光标在文件中的位置
    seek tell应用于网络编程：FTP的作业，断电续传的功能。

f.truncate(size): 对原文件根据字节大小进行截取，必须在句柄可写（r+）的情况下使用,使用r+模式

'''

# f.truncate()

# f = open('other_operate.txt', 'r+', encoding='utf8')
# f.seek(3)  # 调整光标对truncate方法不管用
# f.truncate(9) # truncate截取都是从文件最开始位置进行截取，以字节为单位。
# f.close()

'''
总结：
    最常用的几个方法：read seek tell flush readable writeable
'''


'''
打开文件的第二种方法：
with open(filename, mode, encoding) as f:
    f.read()  # 注意缩进

优点
    1.省略f.close()
    2.一个with open语句可以操作多个文件句柄

with open(filename1, mode, encoding) as f1,\
        open(filename2, mode, encoding) as f2:

缺点: 当在打开文件中继续操作文件时，可能由于执行语句没有执行关闭文件，下面继续调用会出现报错（IOError）
    with open(filename1, mode, encoding) as f1:
        对文件的处理
        f.close()
        with open(filename2, mode, encoding) as f2:
            pass
'''

with open('file_read.txt', encoding='utf-8') as f:
    data = f.read()
    print(f.tell())
    print(data)

文件操作练习

# 1.以读的模式打开一个源文件
# 2.以写的模式创建一个新文件
import os

# 方法一
with open('file_modify.txt', encoding='utf-8') as f1,\
        open('file_modify1.txt', 'w', encoding='utf-8') as f2:

        # 3.将原文件内容读取出来，按照你的要求改成新内容，写入新文件
        # old_content = f1.read() # 慎用read()读取全部，推荐使用for
        # new_content = old_content.replace('alex', 'sb')
        # f2.write(new_content)
        for line in f1.readlines():
            new_line = line.replace('alex', 'sb')
            f2.write(new_line)

# 4.删除原文件
os.remove('file_modify.txt')


# 5.将新文件重命名为原文件
os.rename('file_modify1.txt', 'file_modify.txt')

# 或者
os.replace('file_modify.txt', 'file_modify.txt')



# 方法二
with open('file_modify.txt', 'r+', encoding='utf-8') as f:
    file = f.read()
    f.seek(0)
    f.write(file.replace('sb', 'alex'))