Python入门

Python入门

一、Python基础语法

1、输入输出

代码

name = input("请输入姓名:")
print(name)

结果

请输入姓名:picaj
picaj

2、格式化输出

代码

name = input("姓名:")
age = input("年龄:")
job = input("工作:")
info = '''
----------- info of %s -----------
姓名:%s
年龄:%s
工作:%s
''' % (name,name,age,job)
print(info)

结果

姓名:picaj
年龄:22
工作:student

----------- info of picaj -----------
姓名:picaj
年龄:22
工作:student

3、Python中的占位符

s，获取传入对象的str方法的返回值，并将其格式化到指定位置
r，获取传入对象的repr方法的返回值，并将其格式化到指定位置
c，整数:将数字转换成其unicode对应的值，10进制范围为 0 <= i <= 1114111（py27则只支持0-255）；字符:将字符添加到指定位置
o，将整数转换成八进制表示，并将其格式化到指定位置
x，将整数转换成十六进制表示，并将其格式化到指定位置
d，将整数、浮点数转换成十进制表示，并将其格式化到指定位置
e，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（小写e）
E，将整数、浮点数转换成科学计数法，并将其格式化到指定位置（大写E）
f，将整数、浮点数转换成浮点数表示，并将其格式化到指定位置（默认保留小数点后6位）
F，同上
g，自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是e；）
G，自动调整将整数、浮点数转换成浮点型或科学计数法表示（超过6位数用科学计数法），并将其格式化到指定位置（如果是科学计数则是E；）
%，当字符串中存在格式化标志时，需要用 %%表示一个百分号

二、Python基础数据类型

1、整数型（int）

代码

a=1
print(type(a))

结果

<class 'int'>

2、布尔型（True，False）

代码

a = 1
b = 2
print(a < b, a > b , a != b)

结果

True False True

3.字符串（str）

代码

a = "picaj"
print(a,type(a))

结果

picaj <class 'str'>

4、字符串操纵

4.1拼接

代码

a = "picaj"
b = "my name is "
print(b+a)

结果

my name is picaj

4.2索引与切片

代码

a = 'ABCDEFGHIJK'
# 索引
print(a[0], a[-11])
print(a[3])
print(a[5])
print(a[7])
# 切片
print(a[0:3])
print(a[2:5])
print(a[0:])  # 默认到最后
print(a[0:-1])  # -1 是列表中最后一个元素的索引，但是要满足顾头不顾腚的原则，所以取不到K元素
print(a[0:5:2])  # 加步长
print(a[5:0:-2])  # 反向加步长

结果

索引结果
A A
D
F
H
切片(正向)
ABC
CDE
ABCDEFGHIJK
ABCDEFGHIJ
切片(反向)
ACE
FDB

4.3其他操纵

代码

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

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

# 统计字符串中的元素出现的个数
ret = words.count("e", 0, 30)
print(ret)

# startswith 判断是否以...开头
# endswith 判断是否以...结尾
a = "aisdjioadoiqwd12313assdj"
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 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
ret = words.split(' ')
print(ret)
ret = words.rsplit(' ', 2)  # 加数字指定分割次数
print(ret)

# format的三种玩法 格式化输出
print('{} {} {}'.format('picaj', 18, 'student'))
print('{1} {0} {1}'.format('picaj', 18, 'student'))
print('{name} {age} {job}'.format(job='student', name='picaj', age=18))

# strip
a = '****asdasdasd********'
print(a.strip('*'))
print(a.lstrip('*'))
print(a.rstrip('*'))

# replace
print(words.replace('e', 'a', 2))  # 字符串从左向右开始，把e替换成a，一共替换两次
print(words.isalnum())  # 字符串由字母或数字组成
print(words.isalpha())  # 字符串只由字母组成
print(words.isdigit())  # 字符串只由数字组成

结果

#首字母大写
Beautiful is better than ugly.
#大小写翻转
BEAUTIFUL IS BETTER THAN UGLY.
#每个单词的首字母大写
Beautiful Is Better Than Ugly.

#内容居中，总长度，空白处填充
********test********

#统计字符串中的元素出现的个数
3

#startswith 判断是否以...开头
#endswith 判断是否以...结尾
True
True
True
True

#寻找字符串中的元素是否存在
2
2

#split 以什么分割，最终形成一个列表此列表不含有这个分割的元素。
['beautiful', 'is', 'better', 'than', 'ugly.']
['beautiful is better', 'than', 'ugly.']

#format的三种玩法 格式化输出
picaj 18 student
18 picaj 18
picaj 18 student

#strip的用法
asdasdasd
asdasdasd********
****asdasdasd

#replace
baautiful is batter than ugly.
False
False
False

5、元组与列表

5.1、元组（tuple）

元组被称为只读列表，即数据可以被查询，但不能被修改。

代码

a=('a','b','c','d')
print(a)
print(type(a))

结果

('a', 'b', 'c', 'd')
<class 'tuple'>

5.2、列表（list）

列表相比于字符串，不仅可以储存不同的数据类型，而且可以储存大量数据。

代码

a=['a','b','c','d']
print(a)
print(type(a))

结果

['a', 'b', 'c', 'd']
<class 'list'>

5.3、列表操纵

代码

# 增
li = [1, 'a', 2, 'd', 4]
li.insert(0, 22)  # 按照索引去增加
print(li)
li.append('ddd')  # 增加到最后
print(li)
li.extend(['q,a,w'])  # 迭代的去增
print(li)
li.extend(['q,a,w', 'das'])  # 迭代的去增
print(li)

# 删
li = [1, 'a', 2, 'd', 4, 5, 'f']
a = li.pop(1)  # 按照位置去删除，有返回值
print(a)
del li[1:3]  # 按照位置去删除，也可切片删除没有返回值。
print(li)
li.remove('f')
print(li)
li.clear()
print(li)

# 改
li = [1, 'a', 2, 'd', 4, 5, 'f']
li[1] = 'aaa'
print(li)
li[2:3] = [3, 'e']
print(li)

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

结果

# 增
[22, 1, 'a', 2, 'd', 4]
[22, 1, 'a', 2, 'd', 4, 'ddd']
[22, 1, 'a', 2, 'd', 4, 'ddd', 'q,a,w']
[22, 1, 'a', 2, 'd', 4, 'ddd', 'q,a,w', 'q,a,w', 'das']

# 删
a
[1, 4, 5, 'f']
[1, 4, 5]
[]

# 改
[1, 'aaa', 2, 'd', 4, 5, 'f']
[1, 'aaa', 3, 'e', 'd', 4, 5, 'f']

# 查
3
1
[1, 2, 2, 4, 4, 4, 5]
[5, 4, 4, 4, 2, 2, 1]

6、字典（dict）

字典是python中唯一的映射类型，采用键值对（key-value）的形式存储数据。python对key进行哈希函数运算，根据计算的结果决定value的存储地址，所以字典是无序存储的，且key必须是可哈希的。

代码

a = {"name":"picaj","age":22}
print(a)
print(type(a))

结果

{'name': 'picaj', 'age': 22}
<class 'dict'>

7、字典操纵

代码

# 增
dic = {"age": 22, "name": "picaj"}
dic['li'] = ["a", "b", "c"]
print(dic)
dic.setdefault('k', 'v')
# 在字典中添加键值对时，如果指定的键已经存在则不做任何操作,如果原字典中不存在指定的键值对，则会添加。
print(dic)
dic.setdefault('k', 'v1')
print(dic)

# 删
dic = {"age":22, "name":"picaj"}
dic_pop = dic.pop('age')
# pop根据key删除键值对，并返回对应的值，如果没有key则返回默认返回值
print(dic_pop)
dic_pop = dic.pop('sex','查无此项')
print(dic_pop)
dic['age'] = 18
print(dic)
del dic['name']
print(dic)
dic['name'] = 'demo'
dic_pop = dic.popitem()
# 随机删除字典中的某个键值对，将删除的键值对以元祖的形式返回
print(dic_pop)
dic_clear = dic.clear()
# 清空字典
print(dic,dic_clear)

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

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

#其他操作
dic = {"age":22, "name":"picaj", '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))

结果

# 增
{'age': 22, 'name': 'picaj', 'li': ['a', 'b', 'c']}
{'age': 22, 'name': 'picaj', 'li': ['a', 'b', 'c'], 'k': 'v'}
{'age': 22, 'name': 'picaj', 'li': ['a', 'b', 'c'], 'k': 'v'}

# 删
22
查无此项
{'name': 'picaj', 'age': 18}
{'age': 18}
('name', 'demo')
{} None

#改
{'age': 22, 'name': 'picaj1', 'sex': 'male'}
{'age': 30, 'name': 'picaj1', 'sex': 'male'}

#查
picaj
查无此项

#其他操作
('age', 22)
('name', 'picaj')
('sex', 'male')
age 22
name picaj
sex male
age
name
sex
dict_keys(['age', 'name', 'sex']) <class 'dict_keys'>
dict_values([22, 'picaj', 'male']) <class 'dict_values'>

8、集合

代码

a = {'set',1,2}
print(a)
print(type(a))

结果

{'set', 1, 2}
<class 'set'>

9、集合操纵

代码

# 增
set1 = {'abc', 'def', 123, 'asdas'}
# add()函数的参数只能接收可哈希数据类型，即不可变数据类型，比如整型、浮点型、元组、字符串
set1.add('qwer')
print(set1)
# 我们使用update()向集合中添加元素时，update接收的参数应该是可迭代的数据类型，比如字符串、元组、列表、集合、字典。这些都可以向集合中添加元素，但是整型、浮点型不可以。
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)

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

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

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

# 反交集
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) # 不可以修改,会报错

结果

# 增
{'asdas', 'qwer', 'def', 123, 'abc'}
{'asdas', 'qwer', 'def', 123, 'abc', 'A'}
{'asdas', 'qwer', 'def', '哈', 123, 'abc', 'A'}
{1, 2, 3, 'asdas', 'qwer', 'def', '哈', 123, 'abc', 'A'}

# 删
{123, 'asdas', 'def'}
{'asdas', 'def'}
set()

# 交集
{3, 4, 5}
{3, 4, 5}

# 并集
{1, 2, 3, 4, 5, 6, 7}
{1, 2, 3, 4, 5, 6, 7}

# 差集
{1, 2}
{1, 2}

# 反交集
{1, 2, 6, 7}
{1, 2, 6, 7}

# 子集与超集
True
True
True
True

# frozenset不可变集合
Traceback (most recent call last):
  File "D:\JetBrains\Pythonworks\pythonProject\main.py", line 4, in <module>
    s.add(7) # 不可以修改,会报错
AttributeError: 'frozenset' object has no attribute 'add'
frozenset({1, 2, 3, 4, 5, 6}) <class 'frozenset'>

三、基本运算符

1、算术运算

运算符	描述	示例
+	两个对象进行相加	10 + 10结果20
-	两个对象进行相减	20 - 10结果10
*	两个数相乘	10 * 10结果100
/	两个数相除	100 / 10结果10
%	返回除法后的余数	9 % 2结果1
**	返回幂次方	2**4结果16
//	取整	9 // 2结果4

2、比较运算

运算符	描述	示例
==	判断两个对象是否相等	10 == 10结果True
!=	判断两个对象是否不相等	10 != 20结果True
<>	判断两个对象是否不相等	10 <> 20结果True
>	判断两个对象是否大于	10 > 20结果为False
<	判断两个对象是否小于	10 < 20结果为False
<=或>=	判断两个对象是否小于等于或大于等于	10 <= 10结果为True

3、赋值运算

运算符	描述	示例
=	简单的赋值	c = 10
+=	加等于	c += 10等同于c = c+10
-=	同上	同上
*=	同上	同上
/=	同上	同上
**=	同上	同上
//=	同上	同上

4、逻辑运算

运算符	描述	示例
and	“与”运算，两边同为真则为真，否则为假	10 > 5 and 6 == 6结果为True，10 < 20 and 20 < 3结果False
or	“或”运算，两边只要出现真则为真，两边全部假则为假	10 > 5 or 6 == 7结果为True，10 > 20 or 20 < 3结果False
not	“非”运算，将原来的值取反，真的变为假，假的变为真	not 10 >5结果False，not 10 > 20结果为真

四、流程控制

1、if

1.1、单分支

if 条件:
    满足条件后要执行的代码

1.2、双分支

"""
if 条件:
    满足条件执行代码
else:
    if条件不满足就走这段
"""
age = 48

if age > 50 :
    print("尚能饭否")
else:
    print("廉颇老矣")

廉颇老矣

1.3、多分支

# 例3:if语句多个条件

num = 9
if num >= 0 and num <= 10:    # 判断值是否在0~10之间
    print 'hello'
# 输出结果: hello

num = 10
if num < 0 or num > 10:    # 判断值是否在小于0或大于10
    print 'hello'
else:
    print 'undefine'
# 输出结果: undefine

num = 8
# 判断值是否在0~5或者10~15之间
if (num >= 0 and num <= 5) or (num >= 10 and num <= 15):    
    print 'hello'
else:
    print 'undefine'
# 输出结果: undefine

2、while

print('猜数字游戏开始')
num = 54
while True:
    guess = int(input("您猜数字是什么?(输入0-100的数字)"))
    if guess < num:
        print("您猜小了")
        continue
    elif guess > num:
        print("您猜大了")
        continue
    break

print("您猜对了!")

猜数字游戏开始
您猜数字是什么?(输入0-100的数字)50
您猜小了
您猜数字是什么?(输入0-100的数字)60
您猜大了
您猜数字是什么?(输入0-100的数字)54
您猜对了!

3、for

s = '先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。'

for i in s:
    print(i,end="")
print("\n")
li = ['甲','乙','丙','丁']
for i in li:
    print(i)

dic = {'a':1,'b':2,'c':3}
for k,v in dic.items():
    print(k,v)

先帝创业未半而中道崩殂，今天下三分，益州疲弊，此诚危急存亡之秋也。

甲
乙
丙
丁
a 1
b 2
c 3

4、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)

甲
乙
丙
丁
(0, '甲')
(1, '乙')
(2, '丙')
(3, '丁')
0 甲
1 乙
2 丙
3 丁
100 甲
101 乙
102 丙
103 丁

5、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)

6、循环终止语句

6.1break

用于完全结束一个循环，跳出循环体执行循环后面的语句

6.2continue

和 break 有点类似，区别在于 continue 只是终止本次循环，接着还执行后面的循环，break 则完全终止循环

while ... else ..

while 后面的 else 作用是指，当 while 循环正常执行完，中间没有被 break 中止的话，就会执行 else 后面的语句

五、文件操作

1、文本文件和二进制文件

文本文件:可以使用文本编辑器查看；
二进制文件:保存的内容不是直接给人查看的，而是使用专用软件查看的，例如图片文件、视频文件；

2、文件的操作套路

打开文件；
读写文件； 2.1 读文件:将文件内容读入内存； 2.2 写文件:将内存内容写入文件；
关闭文件；

3、文件操作函数/方法

3.1、文件打开

# open("文件名", "访问方式")
file1 = open("work1.txt","r")
file2 = open("work2.txt","w")

# 使用with结构,可以不用写file.close()
with open('work3.txt','r') as read_f,open('work4.txt','w') as write_f:
    data=read_f.read()
    write_f.write(data)

3.2、文件读写

data1 = file1.read() #读取字符串
file2.write(data1) #写入字符串
data2 = file1.readline() #一次读取一行,返回一个字符串
file2.writelines(data2) #写入列表/字符串
data3 = file1.readlines() #读取全部内容，返回一个列表

3.3、文件关闭

file1.close()
file2.close()

3.4、文件打开方式

访问方式	说明
r	以只读方式打开文件。文件的指针将会放在文件的开头，这是默认模式。如果文件不存在，抛出异常
w	以只写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a	以追加方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入
r+	以读写方式打开文件。文件的指针将会放在文件的开头。如果文件不存在，抛出异常
w+	以读写方式打开文件。如果文件存在会被覆盖。如果文件不存在，创建新文件
a+	以读写方式打开文件。如果该文件已存在，文件指针将会放在文件的结尾。如果文件不存在，创建新文件进行写入

r+b	读写【可读，可写】
w+b	写读【可写，可读】
a+b	写读【可写，可读】

3.5、文件编码

#f=open(...)是由操作系统打开文件，那么如果我们没有为open指定编码，那么打开文件的默认编码很明显是操作系统说了算了，操作系统会用自己的默认编码去打开文件，在windows下是gbk，在linux下是utf-8。
f=open('a.txt','r',encoding='utf-8')

3.6、所有文件操作方法

def close(self, *args, **kwargs): # real signature unknown
        关闭文件
        pass

def fileno(self, *args, **kwargs): # real signature unknown
    文件描述符  
    pass

def flush(self, *args, **kwargs): # real signature unknown
    刷新文件内部缓冲区
    pass

def isatty(self, *args, **kwargs): # real signature unknown
    判断文件是否是同意tty设备
    pass

def read(self, *args, **kwargs): # real signature unknown
    读取指定字节数据
    pass

def readable(self, *args, **kwargs): # real signature unknown
    是否可读
    pass

def readline(self, *args, **kwargs): # real signature unknown
    仅读取一行数据
    pass

def seek(self, *args, **kwargs): # real signature unknown
    指定文件中指针位置
    pass

def seekable(self, *args, **kwargs): # real signature unknown
    指针是否可操作
    pass

def tell(self, *args, **kwargs): # real signature unknown
    获取指针位置
    pass

def truncate(self, *args, **kwargs): # real signature unknown
    截断数据 仅保留指定之前数据
    pass

def writable(self, *args, **kwargs): # real signature unknown
    是否可写
    pass

def write(self, *args, **kwargs): # real signature unknown
    写内容
    pass

def __getstate__(self, *args, **kwargs): # real signature unknown
    pass

def __init__(self, *args, **kwargs): # real signature unknown
    pass

@staticmethod # known case of __new__
def __new__(*args, **kwargs): # real signature unknown
    """ Create and return a new object.  See help(type) for accurate signature. """
    pass

def __next__(self, *args, **kwargs): # real signature unknown
    """ Implement next(self). """
    pass

def __repr__(self, *args, **kwargs): # real signature unknown
    """ Return repr(self). """
    pass

评论区

现在这篇文章还没有人评论呢，快来分享你的想法吧！！！