Python 学习记录

标签：记录 Python tuple list 列表学习 print 返回值元组

前言

第一个程序.py

print("hello python")

基本语法

type(a) = 数据类型

整数（在线进制转换）
- 定义 a = 12
- Python可以处理任意大小的整数，包括负数
- 支持二进制、八进制、十进制、十六进制
  
  进制前缀举例结果
  
  2 0b或者0B a = 0b1010 10
  
  8 0o或者0O a = 0o12 10
  
  10 无 a = 10 10
  
  16 0x或者0X a = 0xa 10
浮点数
- 定义
  
  a = 1.2
  
  b = .4 （b = 0.4 ）
  
  c = 1.2e-4 （科学计数法 e+4 表示10的4次方相反则是-方）
运算
- 整数除法以及浮点数运算结果返回值为浮点数
- 整数加减乘运算，返回值为整数
  
  类型运算返回值
  
  整数 + - * 整数型
  
  整数 / 浮点型
  
  浮点数 + - * / 浮点型
不同除法的返回值

除号返回值

/ 返回值为float浮点数

// 返回值为int型整数

进制	前缀	举例	结果
2	0b或者0B	a = 0b1010	10
8	0o或者0O	a = 0o12	10
10	无	a = 10	10
16	0x或者0X	a = 0xa	10

类型	运算	返回值
整数	+ - *	整数型
整数	/	浮点型
浮点数	+ - * /	浮点型

除号	返回值
/	返回值为float浮点数
//	返回值为int型整数

字符串

定义

a = test''

a = "中文"

a = ''' 双引号"1" 和单引号'2'用三引号'''

转义符号：在Python中，以"\"为转义符号
索引

a = '123456'

a[0] → 1

a[1] → 2

字符串内的元素不可以赋值
运算（有+无-，有*无/）

值值运算结果

a = "123" b = "456" c = a + b c = "123456"

a = "123" c = a * 2 c = "123123"

值	值	运算	结果
a = "123"	b = "456"	c = a + b	c = "123456"
a = "123"		c = a * 2	c = "123123"

格式化 .format用法

name = 'python'
age = 32
# 打印“我是Python，今年32岁了”
str_1 = "我是" + name + "," + "今年" + "32" + "岁了"
print(str_1)
# python2 常用
str_2 = "我是%s，今年%d岁了" % (name, age)
print(str_2)

str_3 = "我是{}，今年{}岁了" .format(name,age)
print(str_3)

str_4 = "我是{name}，今年{age}岁了".format(
    name = 'python',
    age = '32'
)
print(str_4)
# python 3.6+
str_5 = f"我是{name}，今年{age}岁了"
print(str_5)

布尔型
- Bool
  - 真 or 假
  - True or False
  - type(a) = 'bool'
- NONE 空值
  - 空值为无值 a = None
  - a = "" a = 0 均非空值

列表

列表
- 定义
  
  a = [1,2,3,4]
  
  b = [1,'abc',2.0,['a','b','c']]
- 列表可以包含：整数型、浮点型、字符串以及列表
- 列表解释
  
  默认起始位置为0位，从左向右为正值，反之则为负值
- 访问
  
  a[0] → 1
  
  a[0:1] → 1
切片

列表、字符串、元组均可
[a:]返回值

返回值：从起始位置a后的所有位
[a:b] 返回值

a：起始位置

b：末端位置

返回值：从起始位置a开始取b-a位
负向运算[a:-b]

返回值：从起始位置a到-b前（从a开始，去掉倒数b位后的全部）

s = 'abcdefg'
d = s[1:3] # 返回值取从列表s第一位开始，取3-1位
print(d)
s = 'abcdefg'
# 取反向 - 值
print(s[1:3])
print(s[1:-2])

	取值	返回值
a = 'abcdefg'	a[1:3]	bc
a = 'abcdefg'	a[1:-3]	bcd

列表的基本操作

长度： len(list)
最大值： max(list)
最小值： min(list)
重复值： list.count(重复字符)
末尾添加新元素：list.append()
插入元素: list.insert(1,'b')(位置，内容)
删除元素：list.remove()
更新元素：list[1] = '赋值'
翻转列表：list.reverse()
列表排序：list.sort

# 获取列表的基本信息
list1 = [9,1,-4,3,7,11,3]
# 取列表的长度（元素个数）
a = len(list1)
print('list1的长度 =',a)
# 取列表最大值
big = max(list1)
print('list1的最大值=',big)
# 取列表最小值
min = min(list1)
print('list1的最小值=',min)
# 取列表重复值
count_3 =list1.count(3)
print("list1的重复值=",count_3)
print('list1的重复值3，重复次数为：{}'.format(list1.count(3)))
# 列表改变
list2 = ['a','c','d']
# 给列表结尾添加新元素
list2.append('e')
print(list2)
# 在列表元素之间插入新元素
list2.insert(1,'b')
print(list2)
# 删除列表里面的元素
list2.remove('b')
print(list2)
# 更新列表,取列表内元素赋值
list2[0] = 1
print(list2)
# 列表翻转 123 → 321
list3 = ['1','2','3']
list3.reverse()
print(list3)
# 列表排序
list4 = ['3','1','2']
# 正序排序
list4.sort()
print(list4)
# 倒序排序
list4.sort(reverse=True)
print(list4)

元组

创建与访问
- 创建
  
  a = (1, 2, 3, 4)
  
  b = 1, 2,
- 访问
  
  print('a[1]')
  print(a[0:1])
  print(a[-1])

元组的基本操作

长度： len(tuple)
最大值： max(tuple)
最小值： min(tuple)
重复值：tuple.count(重复字符)
index：tuple.index()

# 获取元组基本信息
tuple = (9,1,-4,3,7,11,3)
# 取元组长度
lenth = len(tuple)
print('tuple的长度=',lenth)
# 取最大值
max = max(tuple)
print('tuple的最大值=',max)
# 取最小值
min = min(tuple)
print('tuple的最小值=',min)
# 取重复值
count3 = tuple.count(3)
print(count3)
print('元组中重复值3，重复的次数为：{}'.format(tuple.count(3)),'次')
# 取index
tuple.index(7)
print('tuple中7在第',tuple.index(7),'位')

列表与元组对比

元组是不可变的（Immutable）Python对象，储存在一块固定的内存里。
列表是可变的（mutable）Python对象，需要两块存储空间，一块固定的用于存放实际的列表数据，一块可变得空间用于拓展。

元组的创建与访问要比列表快，列表比元组操作更灵活（支持扩展：删除、添加、排序等操作）

功能对比

列表元组

max ✓ ✓

min ✓ ✓

len ✓ ✓

count ✓ ✓

append ✓

insert ✓

remove ✓

reverse ✓

sort ✓

index ✓

赋值 ✓
综合比较

元组适用于固定性且不轻易改变的数据，访问速度快，安全性高。

列表适用于灵活性较强的数据，便于数据扩展操作。

	列表	元组
max	✓	✓
min	✓	✓
len	✓	✓
count	✓	✓
append	✓
insert	✓
remove	✓
reverse	✓
sort	✓
index		✓
赋值	✓

字典

key 与 value
- key
  
  不可改变的数据类型可以作为键值对的键 key
  
  通常：int整数型、元组、字符串（列表不可以）
- value
  
  可以说任意数据

创建字典

a =

tuple = (1, 2, 3)
c = ['a','b','c'] # 列表
d = (1, 2, 3) # 元组
h = {d:c} # 字典
print(h)

初始化

d = dict()

e = dict(a='1',b='2',c='3')
字典访问

dict['a'] 返回值：字典dict中key值为a的value返回值。

e = dict(a='1',b='2',c='3')

print(e['c'])
基本操作

改变值

a = dict(a='1',b='2',c='3')

返回值：

a['c'] = 1

返回值：

一个字典不可以成为另外一个字典的key值

集合

创建集合

a =
判断key值是否存在与字典中

t = 'a' in b # 判断key值a是否存在与字典b中，返回值：True or False
print(t)
列表转为集合并去除重复值

l = [1,2,3,4,5,5,5,6]
s = set(l)
print(s)
列表去除重复值

l2 = [1,1,2,2,3,3]
s2 = set(l2)
l2= list(s2)
print(l2)
print(list(set(l2)))
字符串转换为集合并去除重复，无序

a = 'abcdefg'
s = set(a)
print(s) # 返回值：

a = {
    'a':1,
    'b':2
}
# 创建集合 *集合，仅有key 无value
a = {'a','b','c'}

b = {
    'a':1,
    'b':2,
    'c':3
}
# 判断key值是否存在与字典中
t = 'a' in b # 判断key值a是否存在与字典b中，返回值：True or False
print(t)

# 列表转为集合并去除重复值
l = [1,2,3,4,5,5,5,6]
s = set(l)
print(s)
# 列表去除重复值
l2 = [1,1,2,2,3,3]
s2 = set(l2)
l2= list(s2)
print(l2)
print(list(set(l2)))
# 字符串转换为集合并去除重复，无序
a = 'abcdefg'
s = set(a)
print(s) # 返回值： {'b', 'a', 'f', 'e', 'd', 'g', 'c'}

集合的基本操作

创建集合
添加元素
删除元素
集合运算-取交集
集合运算-取并/全集
集合运算-取并集并去除交集部分
a-b 去除集合a中与b交集的值

s = {1, 2, 3, 4, 5,}
# 添加元素
s.add(6)
s.add(6) # 重复添加 覆盖
print(s)
# 删除元素
s.remove(6)
# s.remove(6) # 首次已经删除，次删除为空值，程序报错
print(s)
# 集合运算 交并补集
s1 = {1, 2, 3, 4, 5}
s2 = {5, 6, 7, 8, 9}
# 取交集
c = s1 & s2
# 取并/全集
c = s1 | s2
# 取并集且去除交集值
c = s1 ^ s2
# a-b 去除集合a中与b交集的值
c = s1 - s2

IF-条件语句

if 语句

a = int(input('请输入大于1的数字：'))
if a > 1 :
   print(a)

if ... else 语句

a = int(input('请输入数字：'))
if a > 10 :
    print('数字比10大')
else:
    print('数字比10小')

if ... elif ... else 语句

a = int(input('请输入数字：'))
if a > 0 :
    print('结果为正值')
elif a == 0 :
    print('结果为0')
else:
    print('结果为负值')

实践

# 判断成绩
a = float(input('请输入你的成绩：'))
if a <= 60:
    print('完犊子吧')
elif a >= 60 and a < 70 :
    print('D')
elif a >= 70 and a < 80:
    print('C')
elif a >= 80 and a < 90:
    print('B')
elif a >= 90 and a <= 100:
    print('A')
elif a > 100 or a < 0:
    print('无效数据')

while循环

循环体

a = 10
while a > 0:
    print(a)
    a = a -1
print('结束')

注意判断语句，易造成死循环结构

实践

a = float(input('请输入既定目标：'))
b = float(input('请输入目标区间：'))
if a < 0 or a > 100 :
    print('既定目标取值范围为：0~100')
else:
    while a > 0:
        if a == 50:
            print('循环到达既定目标')
            break
        else:
            print(a)
            a = a - b
    print('结束')

瞎写的。。。。

猜数字

print("即将开始一个新的读书游戏，准备好了吗？回复：y/n")
a = input('')
b = 55
if a == 'y' :
    print('游戏规则:\n'
          '1. 随机输入一个数字，采取正确数字\n'
          '2. 你可以根据反馈的结果来更准确的接近正确答案\n')
    c =  float(input('现在你可以输入一个数字开始游戏了！\n'
                    '请输入：'))
    while c != b:
        if c > b:
            print('So Big !')
            c = float(input('请输入：'))
        elif c < b:
            print('SO Small !')
            c = float(input('请输入：'))
    print('You are right !')
elif a == 'n' :
    print('Ok！,Start when youre ready')

for-循环

字符串

a = '123456'
for a in a:
    print('字符串：'+ a)

列表

b = [1,2,3,4,5,6] # 列表 返回值int类型
for b in b:
    print("列表：" + str(b)) #str转化为类型

扩展

name = ['a','b','c','d']
for suoyin,zhi in enumerate(name):
    print('所引位置：[{}] ~ 值：{}'.format(suoyin,zhi))

元组

c = ('a','b','c','d') # 元组
for c in c :
    print('元组：'+ c)

字典

d = {
    1:'a',
    2:'b',
    3:'c'
}
for a,b in d.items(): # 返回key-value键值对
    print('key值：{} = value值： {}'.format(a,b))

集合

e = {1,2,3,4,5,6}
for i in e:
    print(e)

range (a,b,c)
- a : 起始
- b : 终止
- c : 步长
```
for x in range(1,10,2):
    print(x)
```

break和continue

break

终止

for i in range(10):
    print(i)
    if i % 2  != 0:
        break

continue

结束或跳过本段命令，在循环体中结束本轮循环

for i in range(10):
    if i % 2 == 0:
        continue # 结束本次循环，进行下一轮循环
        print('d')
    print(i)

实例

import random
a = random.randint(1,100)
while True :
    num = float(input('请输入：'))
    if num == a :
        print('Your right！{}'.format(a))
        break
    elif num < a :
        print("Small!")
    elif num > a :
        print("Big!")

函数的定义和调用

定义
定义函数
函数体
函数的参数
实例

标签：记录,Python,tuple,list,列表,学习,print,返回值,元组
From： https://www.cnblogs.com/lmzq/p/17140542.html

前言