python快速入门笔记（day1）

因为在另一个记笔记软件上记了，所以有些图片没有再弄到这来，有原链接：
https://shimo.im/docs/jgVxhH39VWVDv3Wc/ 《Python笔记》，可复制链接后用石墨文档 App 或小程序打开

注：

本篇笔记在学过 C++（C）后看，能够快速入门 Python，本篇一些地方只罗列出与 C++不同的地方。

day1:

注释：

1.单行注释，以#开始
2.多行注释，’’’ 被注释内容 ‘’’，或者 “”" 被注释内容 “”" （在 python 中一般‘与“可以通用）

Python 中输出：

在 Python 中输出 print(‘obj’)时，实际上调用的是 sys.stdout.write(obj+’\n’)，pyhon 将你打印的类容打印到控制台，然后追加换行符‘\n’。

当想要输出一行时，导入 from sys import stdout
stdout.write('输入想要输出的值')

变量的定义规则（一般别太奇怪就行）：

变量名只能是 字⺟、数字或下划线的任意组合
变量名的第⼀个字符不能是数字
以下关键字不能声明为变量名
[‘and’, ‘as’, ‘assert’, ‘break’, ‘class’, ‘continue’, ‘def’, ‘del’, ‘elif’, ‘else’, ‘except’,
‘exec’, ‘fifinally’, ‘for’, ‘from’, ‘global’, ‘if’, ‘import’, ‘in’, ‘is’, ‘lambda’, ‘not’, ‘or’,
‘pass’, ‘print’, ‘raise’, ‘return’, ‘try’, ‘while’, ‘with’, ‘yield’]

变量的赋值 ：

在 python 中为了方便赋值，一些常用的数字都存在固定的地址中，例如：1，2, 3 , 4，5//a,b,c,d 等。
基础数据类型 ：
int 类型：
64 位系统上，整数的位数为 64 位，取值范围为 -263～263-1，即
-9223372036854775808～9223372036854775807。
data = v.bit_length() #当十进制用二进制表示时，最少使用的位数。
string 类型：
a = “Eagle’s Lab”
b = ‘’’
啦啦啦啊啦啦啦，
今天我们学习 python!’’’
print(a,b)
1.加了引号的字符都被认为是字符串。
2.加上三引号可以连接多行代码。
3.字符串可以通过+号连接在一起，用*来实现重复。
a=‘ABCDEFG’
可通过下标直接访问如：a[0],a[1]。 也可通过索引 a[a:b]不包括 a，a[a:]从 a 到最后，a[a🅱️c]从 a 到 b 步长为 c。

常用方法（函数大全）:

1. int()把字符串转换为数字 str()把数字转换为字符串 len()获取某个字符占用的字节数 字符串可以用+连接 字符下标可以为负数
   str[起始位置:终止位置:步长]切片，从起始开始截取字符串，到终止位置结束，不包括终止位置 str[::-1]倒序
   str.find()|rfind 字符串查找 str.index()|rindex()字符串查找，与find不同的是返回的结果不同
   str.count(str,start=0,end=len(str))字符串出现的次数
   str.replace(“str”,”str”,替换次数)字符串替换，不会影响原字符串 str.split(“
   “)字符串切割，参数可以不用写自动切割 str.capitalize()把字符串中的第一个字符大写
   str.title()把字符串中每个单词大写
   str.startswith(obj)|endswith(obj)判断字符串是否以obj开头|结尾，返回bool
   str.lower()把所有大写转换为小写 str.upper()把所有小写转换为大写
   str.ljust()返回一个原字符串左对齐，并使用空格填充至长度width的新字符串
   str.rjust(width)返回一个原字符串右对齐，并使用空格填充至长度width的新字符串
   str.center()返回一个原字符串居中对齐，并使用空格填充至长度width的新字符串
   str.lstrip()删除字符串开头的空白字符 str.rstrip()删除字符串末尾的空白字符
   str.strip()删除字符串两端的空白字符 str.partition()把str分成三部分，str前，str,和str后
   str.rpartition()把str分成三部分，str前，str,和str后，从右边开始分
   str.splitlines()按照行分割，返回一个各行作为元素的列表 str.isalpha()判断字符串是否都是字母
   str.isdigit()判断字符串是否都是数字 str.isalnum()判断字符串是否都是数字或字母
   str.isspace()判断字符串是否都是空格 str.join(mystr)每个字符后面添加一个mystr，构建出一个新的字符

字符串常⽤⽅法 ：

words = “beautiful is better than ugly.”
words.capitalize() 首字母大写 words.swapcase() 大小写翻转
words.title() 每个单词的首字母大写

#内容居中，总长度，空白处填充
a = “test”
ret = a.center(20,"*")
print(ret)

ret = words.count(“e”,0,30)字符串 words 0 到 30 中 e 出现的次数
print(ret)
#startswith 判断是否以…开头
#endswith 判断是否以…结尾
print(a.startswith(“a”))
print(a.endswith(“j”))
print(a.startswith(‘sdj’,2,5))
print(a.endswith(‘ado’,7,10))
寻找字符串中元素是否存在：
print(a.find(‘sdj’,1,10)) # 返回的找到的元素的索引，如果找不到返回-1。
print(a.index(‘sdj’,1,10)) # 返回的找到的元素的索引，找不到报错。

以什么分割：split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
words.split('以什么分隔 ')将以这个分割的字符串形成一个列表输出，有返回值（列表）
函数默认会以空格，回车符，空格符等作为分割条件。
也可在（）自定义用什么分割.

例：a="my name is zhangkang"
b="my\nname\nis\nzhangkang"
c="my\tname\tis\tzhangkang"

a=a.split()
b=b.split()
c=c.split()

print(a)
print(b)
print(c)

输出：
['my', 'name', 'is', 'zhangkang']
['my', 'name', 'is', 'zhangkang']
['my', 'name', 'is', 'zhangkang']

a.strip()去掉字符串中的空格，a.strip(’ *’)
默认去掉字符串前后的空格以及\n，\t。
也有返回值，需通过赋值的方式。
a.strip(‘c’)删除 a 中所有 c.

# replace
print(words.replace('e','a',2))
print(words.isalnum()) #字符串由字母或数字组成
print(words.isalpha()) #字符串只由字母组成
print(words.isdigit()) #字符串只由数字组成
print(words.isspace()) #字符串只由空格组成

例：
import string
s = input('请输入一个字符串:\n')
letters = 0
space = 0
digit = 0
others = 0
for c in s:
    if c.isalpha():
        letters += 1
    elif c.isspace():
        space += 1
    elif c.isdigit():
        digit += 1
    else:
        others += 1
print ('char = %d,space = %d,digit = %d,others = %d' % (letters,space,digit,others))

布尔值（True, False) ：

格式化输出 ：
1.第一种方式
name = input(“姓名：”)
age = input(“年龄：”)
job = input(“工作：”)
info = ‘’’
----------- info of %s -----------
姓名：%s
年龄：%s
工作：%s
‘’’ % (name,name,age,job)
print(info)
2.第二种方式
name = input(“姓名：”)
age = input(“年龄：”)
job = input(“工作：”)
info = f’’’
----------- info of {name} -----------
姓名：name
年龄：age
工作：job
‘’’
print(info)

元组：

只可被查询，不能修改。
列表：

增加：

li = [1,'a',2,'d',4]
li.insert(0,22) # 按照索引去增加，索引为 0
print(li)
li.append('ddd') # 增加到最后
print(li)
li.extend(['q,a,w']) # 将字符串拆散了加进去，只会拆一层
print(li)

删除：

pop()弹出最后一个，pop(a)弹出指定索引 a 的位置，pop 有返回值。
del li[a:b]删除 a 到 b。
查：
切⽚去查，或者循环去查。

其他操作：

li = [1,2,4,5,4,2,4]
print (li.count(4)) # 统计某个元素在列表中出现的次数
print (li.index(2)) # 用于从列表中找出某个值第一个匹配项的索引位置
li.sort() # 用于在原位置对列表进行排序，不需要返回值
print (li)
li.reverse() # 将列表中的元素反向存放，不需要返回值
print (li) 

基本运算符：

/：运算符（返回一个浮点数） //:运算符（返回一个整处值） **：运算符（表示 x 的 y 次幂） <>:运算符（表示！=）注：python 中！=符号。
逻辑运算：
and，or，not（学过计算机基础知识的应该不用解释了）

成员运算：

运算符
描述
实例
in 如果在指定的序列中找到值返回 True,否则返回 False，x 在 y 序列中,如果 x 在 y 序列中 返回 True。
not in 如果在指定的序列中没有找到值返回 True,否则返回 False x 不在 y 序列中，如果 x 不在 y 序 列中返回 True。
字典：
字典是 python 中唯⼀的映射类型，采⽤键值对（key-value）的形式存储数据。python
对 key 进⾏哈希函数运算，根据计算的结果决定 value 的存储地址，所以字典是⽆序存储
的，且 key 必须是可哈希的。可哈希表示 key 必须是不可变类型，如：数字、字符串、元
组。

增：

dic[key]=值 例：dic['li'] = ["a","b","c"] 
dic.setdefault('k','v') #'k'为 key,'v'为 value  若字典中没有则添加，要是存在，则返回 value

删：

dic = {"age":18, "name":"aaron"}
dic.pop('age') # pop 根据 key 删除键值对，并返回对应的值，如果没有 key 则返回默认返回值 
dic_pop = dic.pop('sex','查无此项') 若没有返回'查无此项'

del dic['name'] 

# 清空字典 
dic_clear = dic.clear()

改：

dic = {"age":18, "name":"aaron", 'sex':'male'}
dic2 = {"age":30, "name":'demo'}
dic2.update(dic)
# 将 dic 所有的键值对覆盖添加（相同的覆盖，没有的添加）到 dic2 中
print(dic2)
dic2['age'] = 30
print(dic2) 

查：

dic = {"age":18, "name":"aaron", 'sex':'male'}
value = dic['name']
# 没有会报错
print(value)
value = dic.get('abc','查无此项')
print(value)

其他操作:

dic = {"age":18, "name":"aaron", 'sex':'male'}
for i in dic.items():
# 将键和值作为元祖列出
    print(i)
    
for key,value in dic.items():
    print(key,value)
    
for i in dic:
# 只是迭代键
    print(i)

keys = dic.keys()
print(keys,type(keys))
value = dic.values()
print(value,type(value)) 

集合 Set：

• 集合是⽆序的，不重复的数据集合，它⾥⾯的元素是可哈希的(不可变类型)，但是集合
• 本身是不可哈希（所以集合做不了字典的键）的。以下是集合最重要的两点： 去重，把⼀个列表变成集合，就⾃动去重了。
  关系测试，测试两组数据之前的交集、差集、并集等关系。

创建集合：

set1 = set({1,2,'barry'})
set2 = {1,2,'barry'}
print(set1,set2)

集合的增：

set1 = {'abc','def',123,'asdas'}
 ​
 set1.add('qwer')
 print(set1)
 ​
 set1.update('A')
 #update：迭代着增加
 print(set1)
 ​
 set1.update('哈哈哈')
 print(set1)
 ​
 set1.update([1,2,3])
 print(set1)

集合的删

set1 = {'abc','def',123,'asdas'}
 ​
 set1.remove('abc')
 print(set1)
 ​
 set1.pop()
 # 随机删除一个数
 print(set1)
 ​
 set1.clear()
 # 清空合集
 print(set1)
 ​
 del set1
 # 删除合集
 print(set1)

集合的其他操作：

交集（& 或者 intersection）

 set1 = {1,2,3,4,5}
 set2 = {3,4,5,6,7}
 
 print(set1 & set2)
 
 print(set1.intersection(set2))
 ​
 # 列出两个集合中共同拥有的项

并集（| 或者 union）

 set1 = {1,2,3,4,5}
 set2 = {3,4,5,6,7}
 
 print(set1 | set2)
 
 print(set2.union(set1))
  #列出两个集合中所有的项

差集（- 或者 difference）

 set1 = {1,2,3,4,5}
 set2 = {3,4,5,6,7}
 
 print(set1 - set2)
 
 print(set1.difference(set2))
 ​
 # 在 set1 中删除 set2 中有的项

反交集 （^ 或者 symmetric_difference）

 set1 = {1,2,3,4,5}
 set2 = {3,4,5,6,7}
 
 print(set1 ^ set2)
 
 print(set1.symmetric_difference(set2))
 ​
 # 显示 set1 和 set2 不共存的项

子集与超集

 set1 = {1,2,3}
 set2 = {1,2,3,4,5,6}
 
 print(set1 < set2)
 print(set1.issubset(set2))  # 这两个相同，都是说明 set1 是 set2 子集。
 
 print(set2 > set1)
 print(set2.issuperset(set1))  # 这两个相同，都是说明 set2 是 set1 超集
frozenset 不可变集合，让集合变成不可变类型
程 set1 = {1,2,3,4,5,6}
 ​
 s = frozenset(set1)
 print(s,type(s))
 ​
 s.add(7) # 不可以修改,会报错

基础数据类型的总结

按存储空间的占用分（从低到高）

• 数字
• 字符串
• 集合：无序，即无序存索引相关信息
• 元组：有序，需要存索引相关信息，不可变
• 列表：有序，需要存索引相关信息，可变，需要处理数据的增删改
• 字典：无序，需要存 key 与 value 映射的相关信息，可变，需要处理数据的增删改
  其他（for，enumerate，range）
  for 循环：用户按照顺序循环可迭代对象的内容。
  range 基本用法：

range：顾头不顾尾

range(10)–返回 0-9 的数字

for i in range(10):

print(i)

result:0,1,…,9

range(0,10)–等同于 range(10),返回 0-9 的数字

ey:for i in range(0,10):

print(i)

result:0,1,…,9

range(0,10,2)–返回 0-9 的数字，步长为 2

for i in range(0,10,2):

print(i)

result:0,2,4,6,8

range(10,0,-2)–返回 0-9 的数字-倒序，步长为 2

ey:for i in range(10,0,-2):

print(i)

result:10,8,6,4,2

s = '先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。'
 ​
 for i in s:
     print(i)
 ​
 li = ['甲','乙','丙','丁']
 for i in li:
     print(i)
 ​
 dic = {'a':1,'b':2,'c':3}
 for k,v in dic.items():
     print(k,v)

enumerate：枚举，对于一个可迭代的（iterable）/可遍历的对象（如列表、字符串），enumerate 将其组成一个索引序列，利用它可以同时获得索引和值。输出时将会带上索引号。

li = ['甲','乙','丙','丁']
 for i in li:
     print(i)
 ​
 for i in enumerate(li):
     print(i)
 ​
 for index,value in enumerate(li):
     print(index,value)
 ​
 for index,value in enumerate(li,100): #从哪个数字开始索引
     print(index,value)

range：指定范围，生成指定数字。

for i in range(1,10):
     print(i)
 ​
 for i in range(1,10,2):  # 步长
     print(i)
 ​
 for i in range(10,1,-2): # 反向步长
     print(i)

控制之 --if：
if 条件： （一般格式）
pass
elif 条件：
pass
else：
pass
流程控制之 --while：
while 条件 ：
循环体
break ⽤于完全结束⼀个循环，跳出循环体执⾏循环后⾯的语句 。
continue 和 break 有点类似，区别在于 continue 只是终⽌本次循环，接着还执⾏后⾯
的循环，break 则完全终⽌循环 。
while … else …
while 后⾯的 else 作⽤是指，当 while 循环正常执⾏完，中间没有被 break 中⽌的话，
就会执⾏ else 后⾯的语句

文件操作：

基本流程：

f=open('文件名','打开模式','编码方式')
例：f=open('a.txt','r',encoding='utf-8') #默认打开模式就为 r 
通过打开模式进行文件操作
例：data=f.read() 
关闭文件
例：f.close()

打开⼀个⽂件包含两部分资源：操作系统级打开的⽂件+应⽤程序的变量。在操作完毕 ⼀个⽂件时，必须把与该⽂件的这两部分资源⼀个不落地回收，回收⽅法为：

f.close()
#回收操作系统级打开的文件
def f
 #回收应用程序级的变量 

在操作完毕⽂件后，⼀定要记住 f.close(),推荐操作⽅式：使⽤ with 关键字来帮我们管理
上下⽂ 。实现自动关闭文件。

with open('a.txt','r') as read_f,open('b.txt','w') as write_f:
   data=read_f.read()
   write_f.write(data) 

文件编码：

f=open(…)是由操作系统打开⽂件，那么如果我们没有为 open 指定编码，那么打开⽂件
的默认编码很明显是操作系统说了算了，操作系统会⽤⾃⼰的默认编码去打开⽂件，在
windows 下是 gbk，在 linux 下是 utf-8。encoding=

文件的打开模式：

r 只读模式（默认，⽂件必须存在，不存在则抛出异常），w 只写模式（不可读，不存在则创建，存在则清空类容），a 只写模式（不可读，不存在则创建，存在则添加）
r+可读可写，w+可写可读，a+可写可读。若使用 r+需保证文件存在。

文件的操作方法：

close()关闭文件，read(self, *args, **kwargs)读取指定字节数据
readline()读取一行文字 ，line=readline()读取出列表
，write()写
将硬盘存放的该⽂件的内容⼀⾏⼀⾏地读⼊内存，修改完毕就写⼊新⽂件，最
后⽤新⽂件覆盖源⽂件

import os
with open('a.txt') as read_f,open('a.txt.new','w') as write_f:
  for line in read_f:
      line = line.replace('nihao','Hello')
      write_f.write(line)
os.remove('a.txt')
os.rename('a.txt.new','a.txt')