Python 基础语法 :

1、注释

   (1)单行注释 : #

   (2)多行注释 :   

 '''

多行注释一般用于文档说明

类似Java中的 /**

 *

 */

多行注释

多行注释

'''

或 :

"""

多行注释

多行注释

多行注释

"""

2、变量

变量的命名要求 :  字母、数字、下划线

注意 :

(1)数字不能作为开头

(2) 不能以关键字作为变量名

i = 'hello world'

print(i)    # hello world

变量定义 :

定义即赋值   定义的时候不需要去指定数据的类型，Python执行器可以自动判断

# type() : 查看类型

var1 = "word"

print(var1, type(var1))    # word <class 'str'>

var1 = 1

print(var1, type(var1))    # 1 <class 'int'>

3、print函数   （只有print函数时，print前不能有空格）

print(1, 2, 3, 4)      # 1 2 3 4

# sep : 可以设置分隔符

print(1, 2, 3, 4, 5, sep="|")    # 1|2|3|4|5   表示以"|"分割

# end : 可以设置结束符   默认 end='\n' -- 表示换行

print("hello", end='--')     

print("world")           # hello--world   （表示以指定字符作为结束符）

print(">>" * 50)          # 表示输出50个 >> 符

4、关键字

import keyword

print(keyword.kwlist)  # 输出所有的关键字 : ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally',

 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

5、5种基础数据类型

    整型   : int

    字符串    : str

    小数   : float

    布尔类型  : bool

    空类型    : NoneType

注意：

(1)bool类型中的 True 和 False 是需要首字母大写

(2)变量类型可以自动去判断

(3)字符串中单引号和双引号不区分

整型

var1 = 1

print(var1)                 # 1

print(var1, type(var1))     # 1 <class 'int'>  , 写成这样是为了方便查看变量类型

字符串 (单引号和双引号不区分)

var1 = "str1"

print(var1, type(var1))     # str1 <class 'str'>

var1 = 'str1'

print(var1, type(var1))     # str1 <class 'str'>

小数类型

var1 = 1.1

print(var1, type(var1))     # 1.1 <class 'float'>

布尔 (True 和 False 需要首字母大写)

var1 = True

var2 = False

print(var1, type(var1))    # True <class 'bool'>

print(var2, type(var2))    # False <class 'bool'>

空类型

var1 = None

print(var1, type(var1))    # None <class 'NoneType'>

6、类型之间的相互转换

(1)str转换成int

s = '1'

print(int(s), type(int(s)))    # 1 <class 'int'>

print(i, type(i))              # i = int(s)

(2)str转换成float

s1 = "1.1"

print(float(s1), type(float(s1)))    # 1.1 <class 'float'>

(3)float转换成int

f1 = 3.14

print(int(f1), type(int(f1)))        # 3 <class 'int'>

   丢失精度时 不会去做四舍五入

f1 = 3.6

print(int(f1), type(int(f1)))        # 3 <class 'int'>

(4)数值类型转bool :   0 是 False ;  非0 全是True

   字符串型转bool :   ''是 False ;  非''全是True

b = 0

print(bool(b), type(bool(b)))        # False <class 'bool'>

b = 1

print(bool(b), type(bool(b)))        # True <class 'bool'>

b = -1

print(bool(b), type(bool(b)))        # True <class 'bool'>

7、字符串的常见操作 ( 字符串中的索引从0开始 )

str1 = "java Python scala sql"

(1)split  切分字符串 ，生成list集合

list1 = str1.split(" ")

print(list1, type(list1))      # ['java', 'Python', 'scala', 'sql'] <class 'list'>

   将list中的每一个元素拼接成一个字符串

    print("-".join(list1))        # java-python-scala-sql  

(2)strip  去除字符串左右两边的隐藏字符

# \t 表示一个制表符

# \n 表示换行

# \r 表示回车

str1 = " \t \n java Python scala sql \t \n \r"

str2 = str1.strip()

print(str2, type(str2))      # java Python scala sql <class 'str'>

(3)提取字符串  -- 切片

规则：[开始位置:结束位置:步长]

开始位置是从0开始,不包含结束位置，步长不写默认为1可以省略  [开始:结束)

str1 = "java Python scala sql"

# 不加步长

print(str1[5:11])      # Python

# 加步长   （开始 + 步长 < 结束 --> 取值）

print(str1[5:11:2])    # Pto     （开始取索引5：P   第一次+2: 5+2<11 取索引7：t   第二次+2: 7+2<11 取索引9：o   第一次+2: 9+2=11 不取值，结束）

(4)字符串反转

str1 = "java Python scala sql"

print(str1[::-1])      # lqs alacs nohtyP avaj

需求: 只反转Python

负值取值是从后往前数 （最后一个数为 -1）

print(str1[-11:-17:-1])       # nohtyP

(5)获取字符串长度

print(len(str1))      # 21

8、格式化

a = 10

b = 3

(1)方式一 : 先定义一个模板，再通过format()方法实现

str_format = "{} * {} = {}"                 # 模板  其中{}相当于一个占位符             

print(str_format.format(a, b, a * b))       # 通过format()方法给占位符传值，三个占位符分别传入参数 a  b  a*b   ,结果是: 10 * 3 = 30

(2)方式二

# %d   : 表示数字

# %s   : 表示字符串

# %f   : 表示浮点型(小数点后6位)

# %.nf : 表示输出小数点后n位

print("%d * %d = %d" % (a, b, a * b))       # 10 * 3 = 30

print("%s * %d = %d" % ('10', b, a * b))    # 10 * 3 = 30

print('%f' % 3.14)          # 3.140000

print('%.1f' % 3.14)        # 3.1

9、算术运算符  -- 整型、浮点类型都可以参与算术运算

#    +  -  *  /  %  //  **

#    %  : 表示取余

#    // : 表示整除

#    ** : 表示次方

a = 10

b = 3

print(a + b)     # 13

print(a - b)     # 7

print(a * b)     # 30

print(a / b)     # 3.33333...

print(a % b)     # 1

print(a // b)    # 3

print(a ** b)    # 1000

    如果是两个 ** 号 , 则需要从后往前计算

print(2 ** 3 ** 2)       #  = 2^(3^2) = 2^9 = 512

如果是两个 // 号 , 则需要从前往后计算

print(10 // 3 // 2)      # = 3 // 2 = 1

  逻辑运算符  -- 布尔类型通常用于逻辑运算以及条件表达式(if、while)

# 与  或   非    异或

(1) 与   :  &   (and)

(2) 或   :  |   (or)

(3) 非   :  not

(4) 异或 :  ^   (相同为False 、 不同为True)

t = True

f = False

print(t & f)       # False

print(t and f)

print(t | f)    # True

print(t or f)

print(not f)    # True

print(t ^ f)    # True

10、Python的4大基础数据容器  -- 类似Java中的集合(Collection)

    (1)列表 List      -- 重复 有序  支持切片

    (2)元组 tuple     -- 重复 有序  不可变  支持切片

    (3)集合 set       -- 不重复 无序

    (4)字典 dict      -- 重复 有序

# 查看容器里有多少个元素 :   len() 方法

>>>>>>>>>>>>>  (1) 列表 list  <<<<<<<<<<<<<<<<

list:

定义: 用 [] 定义一个list列表

特点:

1)可以存储不同类型的数据

2)可以存储相同数值的数据   -- 重复

3)存储数据内容是有序的     -- 有序

4)列表中的元素是可以被删除的

5)列表中可以嵌套列表

list1 = [1, 1, 2, 3, 1.1, True, "str"]

print(list1) # [1, 1, 2, 3, 1.1, True, 'str']

(1)取元素:

  通过索引(index)取值,从0开始取值

print(list1[0])         # 1

(2)切片:

规则: [开始位置(包含):结束位置(不包含):步长]

取所有的值:

print(list1[::])       # [1, 1, 2, 3, 1.1, True, 'str']

print(list1[2:4:1])    # [2,3]

反序列取值:

print(list1[::-1])     # ['str', True, 1.1, 3, 2, 1, 1]

(3)修改元素:

索引下标从0开始

list1[2] = "A"

list1[3] = 'a'        # str类型 "" 与 '' 效果相同

print(list1)          # [1, 1, 'A', 'a', 1.1, True, 'str']

(4)删除元素:

1) pop():  删除列表中最后一个元素

   pop(index):  删除列表中指定位置的元素

list1.pop()

list1.pop(2)

2) remove():  删除列表中给定的值，如给1删1，给'a'删'a'。如果出现重复值，删除第一个出现的值。

list1.remove('a')

print(list1)          # [1, 1, 'A', 1.1, True]

(5)查找元素:

index(num)

print(list1.index(1.1))      # 3

print(list1.index(True))     # True被默认先从1开始查找，若没有则找到True为止，否则不输出值

   False被默认先从0开始查找，若没有则找到False为止，否则不输出值

(6)增加元素:

1) append():  在列表的末尾追加元素(list列表可以嵌套列表)

list1.append([1, 2])

print(list1)          # [1, 1, 'A', 1.1, True, [1, 2]]

2) insert():  在列表的指定索引位置插入元素

list1.insert(4, False)

print(list1)          # [1, 1, 'A', 1.1, False, True, [1, 2]]

(7)排序:

        sort()方法

list2 = [3, 4, 1, 2]

list2.sort()

print(list2[::])         # [1,2,3,4]

print(list2[::-1])       # [4,3,2,1]

(8)合并:

1) extend函数:  将另外一个列表追加到当前列表末尾     -- 改变当前list

list2 = [1, 2, 3, 4]

list3 = [6, 7, 8, 9]

list2.extend(list3)  # 将 list3 追加到 list2

print(list2)             # [1,2,3,4,6,7,8,9]

2) + :  将两个 list 合并成一个新的 list              -- 不改变当前list

list4 = list2 + list3

print(list4)  # [1, 2, 3, 4, 6, 7, 8, 9, 6, 7, 8, 9]

(9)反转:

    reverse()方法

list4.reverse()

print(list4)             # [9, 8, 7, 6, 9, 8, 7, 6, 4, 3, 2, 1]

等同于:

print(list4[::-1])        

(10)统计:   -- 若出现True, 会将其作为1统计; 若出现False, 会将其作为0统计

count()方法

list5 = [1, 1, 2, 3, 1, 0, True, False]

print(list5.count(1))    # （统计1出现的次数）3+1 = 4

print(list5.count(0))    # 2

(11)清除:

clear()方法

list5.clear()

print(list5)             # []

>>>>>>>>>>>>>  (2) 元组 tuple  <<<<<<<<<<<<<<<<

定义 :  通过 () 定义一个元组

特点:

1)可以存储不同类型的数据

2)可以存储重复数据      -- 重复

3)元组是有序的          -- 有序

4)元组是不可变的

tuple1 = (1, 1, 2, 3, 1.1, True, "str")

print(tuple1)              # (1, 1, 2, 3, 1.1, True, 'str')

(1)取元素:

通过索引(index)取值,从0开始取值

print(tuple1[4])           # 1.1

(2)改变元素   --  不可以修改

# tuple1[3] = "A"

# print(tuple1)      # 错误

(3)统计:      -- True 等于 1 ; False 等于 0

count()方法

print(tuple1.count(1))     # 3

>>>>>>>>>>>>>  (3) 集合  set   <<<<<<<<<<<<<<<<

定义 :  使用 {} 定义一个set集合

特点：

1)set集合可以存储不同类型数据

2)set集合存储不了重复数据     -- 不重复

3)set集合是无序的   -- 无序

set1 = {1, 1, 2, "hello", False, 1.1}

print(set1)                 # 因为无序且不重复，所以结果不唯一

(1)取元素:

通过 for 循环取数据 ;  不能通过下标索引进行取数据,

# print(set1[2])      # 错误

for i in set1:

print( i, end='  ')          # False  1  2  1.1  hello   

print()               # 表示换行

(2)删除数据:

    1) pop():  随机删除列表中一个元素

set1.pop()

print(set1)           # 无序，删除结果不唯一

2) remove():  删除列表中给定的值，如给1删1，给'a'删'a'。如果出现重复值，删除第一个出现的值。

set1.remove("hello")

print(set1)           # 删除了'hello' ,但输出结果无序不唯一

(3)增加元素

set1.add(1)      # 添加不成功 重复

set1.add(2)  # 添加不成功 重复

set1.add(3)  # 添加成功

print(set1)

(4)集合运算

1) &  :   求两个集合的交集

2) |  :   求两个集合的并集

3) -  :   集合去重 ，前者减后者

set2 = {2, 3, 4}

set3 = {3, 4, 5}

print(set2 & set3)   # {3,4}

print(set2 | set3)   # {2,3,4,5}

print(set2 - set3)     # {2}

>>>>>>>>>>>>>  (4) 字典  dict  <<<<<<<<<<<<<<<<

定义:  通过 {K:V} 定义一个字典

特点:

1)key是唯一的, 若出现相同的key，后面的value会覆盖前面的value

2)通过Key进行取值

3)当Key中出现 1 和 TRUE 、 0 和 False 后会出现相同key替换现象

4)Key不可变, 所以key可以是基本数据类型、元组 , 不可以是列表、集合

5)Value可以是任意类型元素, Value的值可以直接根据类型取出

6)字典可以嵌套字典

7)查询速度并不会随着元素的增多而变慢

dict = {

'x1': 55,

'x1': 66,

1: "1",

0: "0"

}

print(dict)       # {'x1': 66, 1: '1', 0: '0'}    Key唯一，且Value默认对应最后一个Key

(1) 获取元素:

通过Key进行取值 ,  而无法通过下标index进行取值

1) 方式一:

print(dict1['x1'])          # x2

print(dict1['x11'])         # 不存在key，报错

    2) 方式二（推荐）:  

get()方法

print(dict1.get("x1"))                 # x2

print(dict1.get('x11', '不存在'))      # 默认返回 None， 也可以返回自定义的值: 不存在

(2) 删除key:   pop()

dict1.pop("k1")    # 删除 key 为 "k1" 的 kv

(3) 增加/修改Key对应的Value:

dict1['x11'] = 'v11'            # 若字典没有key，就添加进去

dict1['x1'] = 'x3'              # 若字典有key， 就修改key对应的value

print(dict1['x1']) # x3

(4)常规操作:

1) keys()   :  取出所有的key  （返回值是一个列表）

2) values() :  取出所有的value  （返回值是一个列表）

3) items()  :  取出所有的k-v  （返回值是一个元组）

dict2 = {

'x1': 55,

'x1': 66

1: "1",

0: "0"

}

print(dict2)

print("所有的keys: ", dict2.keys())         # 所有keys: dict_keys(['x1', 1, 0])

print("所有的values: ", dict2.values())     # 所有values: dict_values([66, '1', '0'])

print("所有的k-v: ", dict2.items())     # 所有k-v: dict_items([('x1', 66), (1, '1'), (0, '0')])

(5)扩充字典

dict1 = {

'x1': "x1",

"x1": 'x2',

1: "1",

0: "0",

True: "true",         # 1 等价于 True  ,  这里 1替换True

False: 'false',       # 0 等价于 False ,  这里 0替换False

(1, 2, 3): "tuple(1,2,3)",       # 可以出现元组  , 因为字典中的Key为不可变元素  , 而元组也不可修改

# [1, 2, 3]: "list[1,2,3]",      # 不可以出现列表  , 因为列表可修改

"xx1": [1, 2, 3],           # value 可以为任意类型数据

"xx2": {                    # 这也是一种字典, 字典可以嵌套字典

"xxx1:": "vvv1",

"xxx2": {

"xxxx1": "4x1"

}

}

}

print(dict1)        # {'x1': 'x2', 1: 'true', 0: 'false', (1, 2, 3): 'tuple(1,2,3)', 'xx1': [1, 2, 3], 'xx2': {'xxx1:': 'vvv1', 'xxx2': {'xxxx1': '4x1'}}}

(6)取嵌套字典值

print(dict1.get('xx2').get('xxx2').get('xxxx1'))       # 4x1

11、遍历容器 （Java中的集合(Collection)）

    (1)列表 List      -- 重复 有序

    (2)元组 tuple     -- 重复 有序

    (3)集合 set       -- 不重复 无序

    (4)字典 dict      -- 重复 有序

(1)遍历列表

ls1 = [3, 4, 5]

for i in ls1:

print(i)

(2)遍历元组

tup1 = (3, 4, 5)

for t in tup1:

print(t)

(3)集合Set

set4 = {4, 4, "hello", True}

for s in set4:

print(s)

(4)字典dict

dict2 = {

'xx1': "xx1",

'xx2': "xx2",

'xx3': "xx3",

}

1) keys()   :  取出所有的key  （返回值是一个列表）

2) values() :  取出所有的value  （返回值是一个列表）

3) items()  :  取出所有的k-v  （返回值是一个元组）

for key in dict2.keys():

print(key)

for values in dict2.values():

print(values)

    # 方式一 : kv

for kv in dict2.items():

print(kv)              # 结果是（'xx' , 'xx'）

print(kv[0], kv[0])    # 结果是 xx xx

# 方式二 : k, v

for k, v in dict2.items():

print(k, v)            # 结果是 xx xx

12、range 函数   --  for经常会和range一起使用

range 传值是一个区间: [起始，结束)   起始位置如果是0, 可以不写

(1) 输出 0~9    0 1 2 3 4 5 6 7 8 9

for i in range(10):

print(i)           

(2) 步长 : 输出1~9，每隔2输出一个  1 3 5 7 9

for j in range(1, 10, 2):

print(j)

(3)需求：获取一个从1...100的列表

方式一:

list6 = []

for i in range(1, 101):

list6.append(i)

print(list6)

方式二: 列表推导式 -- for每获取到一个数就赋值给i，i立即输出到list列表。

list7 = [i for i in range(1, 101)]     （等价 :  i = for i in range(1, 101)）

print(list7)

(4)需求：获取一个从1...100的奇数列表

方式一：列表推导式加步长

list7 = [i for i in range(1, 101, 2)]

print(list7)

方式二: 列表推导式加奇偶判断

list7 = [i for i in range(1, 101) if i % 2 == 1]

print(list7)

13、join 和 split

    split自动生成一个列表

str2 = "java, python, scala,"

print(str2.split(','))        # ['java', ' python', ' scala', '']

list8 = str2.split(',')

将其变成一个字符串:

print(','.join(list8))

14、九九乘法表

print("\n".join(['\t'.join(['{} * {} = {}'.format(j, i, j * i) for j in range(1, i + 1)]) for i in range(1, 10)]))