Python语法1

目录

• 变量
  • 命名规则
  • 变量赋值
• 注释
• print函数
  • sep
  • end
• 五大基本数据类型
  • 整形（int）
  • 浮点型（float）
  • 字符串（str）
    • 切分
    • 截取
    • 长度
    • 替换
    • 查找
    • 反转
    • 去除字符串两边的隐藏字符
  • 布尔型（bool）
  • 空值（none）
• 运算符
  • 算数运算符
    • + - * / % ** //
  • 逻辑运算符
• 类型转换
• 数据容器
  • 列表list []
    • 常见用法
  • 元祖tuple ()
  • 字典dict {}
  • 集合set {}
• 常用函数
  • enumerate函数
  • zip函数
  • 格式化字符串
  • range函数
  • 列表推导式
  • 打印列表
  • 九九乘法表

变量

命名规则

变量名必须是大小写英文字母、数字或下划线 _ 的组合，不能用数字开头，并且对大小写敏感

变量赋值

同一变量可以反复赋值，而且可以是不同类型的变量

i=2;
i="name";
print(i)

D:\ALanzhishujia\soft\python\python.exe C:/Users/19768/PycharmProjects/PythonLearning/demo1.py
2

Python中用","连接，而JAVA用"+"连接

i = 2
print("i", 2)

i 2

ublic static void main(String[] args) {
        int i=2;
        System.out.println("i"+2);
    }
i2

注释

单行注释用 # 快捷键 ctrl+/
多行注释""" 注释 """ 或者用单引号

print函数

sep

print输出中默认是用空格分隔，可以通过sep更换

end

end控制最后每一个print结尾是怎样分隔

print(1, 2, 3, 4, 6, 7, sep="*", end='\t')
# \t表示键盘中的tab键
print(1, 2, 3, 4, 5, 6)

1*2*3*4*6*7	1 2 3 4 5 6

五大基本数据类型

整形（int）

i = 1
print(i, type(i))
# type()可以得到数据类型
1 <class 'int'>

浮点型（float）

字符串（str）

切分

str = "i love china"
str1 = str.split(" ")
# 返回一个list
print(str1)

['i', 'love', 'china']

截取

# 直接通过下标截取
print(str[0])
print(str[4])
# [a:b:c:] a起始下标 b结尾下标 c步长，不写默认为1，指多少几个单位截取一次
# 左闭右开
print(str[2:6:1])
print(str[::2])
print(str[-2])

i
v
love
ilv hn
n

长度

print(len(str))
12

替换

print(str.replace("love", "loving"))

i loving china

查找

print(str.index("i"))
0

反转

print(str[::-1])

anihc evol i

去除字符串两边的隐藏字符

# \r表示回车，将光标移到首位
# win下回车是指\n+\r
print("\n\t\rabc ")
print("\n\t\rabc ".strip())

abc 
abc

布尔型（bool）

空值（none）

运算符

算数运算符

+ - * / % ** //

a = 10
b = 3
print(a + b)
print(a - b)
print(a * b)
print(a / b)
print(a % b)
# 10的三次方
print(a ** b)
# 取整，相当于java中/
print(a // b)
#先算后面，2的9次方
print(2**3**2)
print(30//7//3)

13
7
30
3.3333333333333335
1
1000
3
512
1

逻辑运算符

bool1 = 1
bool2 = 0
print(bool1 & bool2)  # 0
print(bool1 and bool2)  # 0
print(bool1 | bool2)  # 1
print(bool1 or bool2)  # 1
print(bool1 ^ bool2)  # 1
print(not bool1)  # Flase

类型转换

函数 int()、float()、str() 和 bool() 分别用于将变量转换 成整型、浮点型、字符串和布尔型变量

# 对于数值型，除0以外都是true
# 对于字符串，除空字符串以外都是true
print(bool("abc"))  # True
print(bool(""))  # False
print(bool(1))  # True
print(bool(0))  # False
print(bool(0.0))  # False
print(bool(None))  # False

数据容器

列表list []

列表(list)是一个有序的序列结构，序列中的元素可以是不同的数据类型,元素可以不唯一（可以重复）

常见用法

# 获取元素
list1 = [1, 2, 7, 4, 5]
print(list1[4])  # 5
print(list1[0:3])  # [1, 2, 7]
print(list1[::-1])  # [5, 4, 7, 2, 1]
# 增
list1.append(8)
print(list1)  # [1, 2, 7, 4, 5, 8]
list1.insert(1, 1.1)
print(list1)  # [1, 1.1, 2, 7, 4, 5, 8]
# 改
list1[2] = "3"
print(list1)  # [1, 1.1, '3', 7, 4, 5, 8]
# 删
print(list1.pop())  # 将最后一个元素拿出来  8
list1.remove("3")
print(list1)  # [1, 1.1, 7, 4, 5]
# 升序降序
list1.sort()
print(list1)  # [1, 1.1, 4, 5, 7]
list1.sort(reverse=True)
print(list1)  # [7, 5, 4, 1.1, 1]

元祖tuple ()

元组(tuple)数据结构与列表类 似，其中元素可以有不同的类型
但是元组中的元素是不可变的， 即一旦初始化之后，就不能够再 做修改(报错:元组对象不支持 赋值)

tuple1 = (1, 2, 3, "china", 8.7)
print(tuple1.index("china"))  # 3
print(tuple1.count(2))  # 1 出现次数
print(tuple1[2])  # 3
print(tuple1[2::])  # (3, 'china', 8.7)

字典dict {}

字典是一种大小可变的键值对集，其中的键(key)和 值(value)都是Python对象
字典用在需要高速查找的地方
字典中的数据元素是无序的，并不会按照初始化的顺序排列。不同键所 对应的值可以相同，但是字典中的键必须是唯一的

dict1 = {
    "k1": "v2",
    78: "v2",
    0: "v3",
    # list1: "v4",
    # True: "v5"  不能是这些
    2: list1
}
print(dict1)
# 取元素
print(dict1[0])
print(dict1.get(78))
print(dict1.get(99, "不存在就返回"))
# 增
dict1["app"] = "append"
print(dict1)
# 删
dict1.pop("app")
del dict1[2]
print(dict1)
# 改
dict1["k1"] = "vvvvv2"
print(dict1)


{'k1': 'v2', 78: 'v2', 0: 'v3', 2: [7, 5, 4, 1.1, 1]}
v3
v2
不存在就返回
{'k1': 'v2', 78: 'v2', 0: 'v3', 2: [7, 5, 4, 1.1, 1], 'app': 'append'}
{'k1': 'v2', 78: 'v2', 0: 'v3'}
{'k1': 'vvvvv2', 78: 'v2', 0: 'v3'}

集合set {}

集合(set)是一种无序集，它是一组键的集合，不存储值
去重。把一个列表变成集合，就自动去重了

set1 = {1, 2, 3, 3, "china", 8.5, None}
print(set1, type(set1))  # {1, 2, 3, None, 8.5, 'china'} <class 'set'>
set1.add(2)  # 和append的区别就是add会自动去重

set2 = {1, 2, 3, 4, 5, 6}
set3 = {4, 5, 6, 7, 8, 9}
print(set2 & set3)  # 交集 {4, 5, 6}
print(set2 | set3)  # 并集 {1, 2, 3, 4, 5, 6, 7, 8, 9}
print(set2 - set3)  # 差集 {1, 2, 3}
print(set3 - set2)  # 差集 {8, 9, 7}

常用函数

enumerate函数

因为在遍历的时候没有下标，所有可以使用enumerate函数加下标

for i in list1:
    print(i)

for i in enumerate(list1):
    print(i)


7
5
4
1.1
1
(0, 7)
(1, 5)
(2, 4)
(3, 1.1)
(4, 1)

zip函数

将list压缩成dict

list2 = ["k1", "k2", "k3"]
list3 = ["v1", "v2", "v3"]
for i in zip(list2,list3):
    print(i)

('k1', 'v1')
('k2', 'v2')
('k3', 'v3')

格式化字符串

str_format = "{}*{}={}"
print(str_format.format(3, 5, 3 * 5))  # 3*5=15
# %d只能是整形，%s表示字符串，%3.f表示保留三位小数
print("%d*%d=%d" % (3, 5, 3 * 5))  # 3*5=15

range函数

用于生成序列，左闭右开

for i in range(1, 11, 2):
    print(i)


1
3
5
7
9

列表推导式

list1 = [i for i in range(1, 11)]
print(list1)
list1 = [i for i in range(1, 11) if i % 2 == 0]
print(list1)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[2, 4, 6, 8, 10]

打印列表

# 这里list1内容需要为str类型
list2 = [str(i) for i in list1]
print("|".join(list2))  #2|4|6|8|10

九九乘法表

print("\n".join([("\t".join(["{}*{}={}".format(i, j, i * j) for j in range(1, i + 1)])) for i in range(1, 10)]))
# 拆开写
# print("\n".join([str(i) for i in range(1, 10)]))
# 然后把里面的str(i) 变成("\t".join(["{}*{}={}".format(i, j, i * j) for j in range(1, i + 1)]))