python--基础1

目录

一、计算机编程思想

二、常用函数

三、字符串

 四、四种集合数据类型

---

---

一、计算机编程思想

        1.1 面向机器：把要解决的问题  转化为  如何操作机器（寄存器、内存）。

        1.2 面向过程：把要解决的问题描述为一个过程，过程执行完毕，问题得到解决。

        1.3 面向对象：把要解决的问题中的事物抽象为类(属性和方法)，再通过类创建对象，通过对象来操作属性和方法。

        1.4 计算机编程语言按运行机制

                1）编译型：根据不同平台的特性进行代码编写，然后有编译器进行编译。C、C++

                2）解释型：通常不考虑平台特性，由解释器解释。VB、python

                3）编译+解释型：

       1.5 转义字符

# 八进制转义字符，以 \ooo 的形式表示，ooo 是一到三位八进制数
# 八进制数每个位的取值是 0-7
print('\101')   # \101 ----> 65  ASCII码表中的A


# 十六进制转换义字符，以 \xHH 形式表示，即 \x 开始后跟两位十六进制数
print('\x41\x42')    # \x41 ----> A 的十六进制转义


# 水平制表符  '\t' （占8位，超过占8的倍数）
print("12345678123456781234567812345678")
print("12345678\t123456\t123")
输出：
12345678123456781234567812345678
12345678	123456	123

         1.6 运行

            

           

二、常用函数

        2.1 随机数：Python 没有创建随机数的函数，但有一个 random 的内置模块，可用于生成随机数。

import random   # 导入 random 模块
print(random.randrange(10,15))   # 产生 10 - 14 之间的随机数

        2.2 bool函数

bool() 函数可判断任何值，并返回 True 或 False：

print(bool(1))
print(bool(0))
print(bool(0.5))
print(bool(0.0))
print(bool("Hello"))
print(bool(""))       # False
x = 5
print(bool(x))

对于 bool() 函数：
1. 除空字符串""外，任何字符串均为 True；
2. 除 0 外，任何数字均为 True；
3. 除空列表[]、元组()、集合{}和字典{}外，任何列表、元组、集合和字典均为 True；
4. None 为 False；
5. False 当然也为 False；
6. 对于对象，如果对象由带有 __len__ 函数的类生成的，且该函数返回 0 或 False，则为 False。

返回 False 的对象举例：

class myclass:
  def __len__(self):
    #return 0
    return False

o = myclass()
print(bool(o))

        2.3 isinstance

Python 还有很多返回布尔值的内置函数，例如 isinstance() 函数，该函数可用于确定对象是否具有某种数据类型：

x = 1
print(isinstance(x, int))   # True
print(isinstance(x, str))   # False

三、字符串

1、赋值
 
    s1 = "你好！"  # "我叫张三" 或 '我叫张三'
    s2 = """我叫张三，
         今年 20 岁，
         我是深圳人。
         现在学习 Python 编程知识。""" #多行字符串，使用三个引号（单引号或双引号都可以）
    s3 = '''
         我叫李四，
         今年 21 岁，
         我是北京人。
         现在和张三一起学习 Python 编程知识。
         '''


2、方括号可用于访问字符串的元素，格式：变量名[索引]。注意索引都是从 0 开始的。

    2.1
       s = "ABC"
       print(s[0])   # A
       print(s[1])   # B
       print(s[2])   # C
    2.2
       s = "1234567890"
       print(s[3:8]) # 45678，从位置 3（包含）到位置 8（不包含）的字符串
    2.3
       s = "1234567890"
       print(s[-1])  # 0
       print(s[-10]) # 1即-字符串的长度
       print(s[-8:-1])  # 3456789，注意不包含 -1 处的字符


3、计算字符串长度，使用 len() 函数。如：

    s = "Hello"
    print(len(s))   # 5
    print(len(s))   # 1，有一个换行符
    print(s[-len(s)])  # H，-len(s) 是字符串 s 的第一个字符的位置


4、strip() 方法删除开头和结尾的空白字符：

    s = "  Hello world!   "
    print(s)
    print(s.strip())   # 返回删除了首尾空格的新串
    print(s)           # 原串的首尾空格并没有删除


5、lower() 和 upper() 方法分别返回转换为小写和转换为大写的新串：

    s = "HELLO world"
    print(s.lower())
    print(s.upper())


6、replace(os, ns) 用另一段字符串 ns 来替换原字符串中的 os 子串：

    s = "Hello! Biden."
    print(s.replace("Biden", "Trump"))  # 找到了则替换成功


7、split(sep) 方法在找到分隔符的实例 sep 时将字符串拆分为子字符串，返回字符串列表：

    s = "Hi!Biden!Trump!OK"
    print(s.split("!"))     # ['Hi', 'Biden', 'Trump', 'OK']


8、使用 in 或 not in 关键字，可以检查字符串中是否存在特定短语或字符。

    s = "Hello"
    print("ll" in s)      # True
    print("ll" not in s)  # False
    print("LL" in s)      # False
    print("LL" not in s)  # True


9、可以使用 + 号将两个字符串拼接起来生成一个新串。

    s1 = "Hello "
    s2 = "world"
    print(s1 + s2)
    s = "张三"
    print("我叫" + s)

    但是不能将字符串与数字相加，这是错误的：
    age = 20
    print("我今年" + age + "岁")  # 运行时报错：TypeError: can only concatenate str (not                 "int") to str


10、要解决以上问题，可以使用 format() 函数来进行格式化。格式：含占位符的字符串变量名.format(参数列表)。

    s = "我今年 {} 岁"
    print(s.format(20))

    可以有多个占位符：

    s = "我叫{}，今年 {} 岁，我来自{}。"
    print(s.format("张三", 20, "深圳"))

    可以为占位符指定参数位置（参数位置从 0 开始编号）：

    s = "我叫{2}，今年 {1} 岁，我来自{0}。"
    print(s.format("深圳", 20, "张三"))


11、Python 内置字符串方法列表

    casefold()      把字符串转换为小写。
    center()        返回居中的字符串。
    count()         返回指定值在字符串中出现的次数。
    encode()        返回字符串的编码版本。
    endswith()      如果字符串以指定值结尾，则返回 true。
    expandtabs()    设置字符串的 tab 尺寸。
    find()          在字符串中搜索指定的值并返回它被找到的位置。
    format()        格式化字符串中的指定值。
    format_map()    格式化字符串中的指定值。
    index()         在字符串中搜索指定的值并返回它被找到的位置。
    isalnum()       如果字符串中的所有字符都是字母数字，则返回 True。
    isalpha()       如果字符串中的所有字符都在字母表中，则返回 True。
    isdecimal()     如果字符串中的所有字符都是十进制数，则返回 True。
    isdigit()       如果字符串中的所有字符都是数字，则返回 True。
    isidentifier() 	如果字符串是标识符，则返回 True。
    islower()       如果字符串中的所有字符都是小写，则返回 True。
    isnumeric()     如果字符串中的所有字符都是数，则返回 True。
    isprintable()   如果字符串中的所有字符都是可打印的，则返回 True。
    isspace()       如果字符串中的所有字符都是空白字符，则返回 True。
    istitle()       如果字符串遵循标题规则，则返回 True。
    isupper()       如果字符串中的所有字符都是大写，则返回 True。
    join()          把可迭代对象的元素连接到字符串的末尾。
    ljust()         返回字符串的左对齐版本。
    lower()         把字符串转换为小写。
    lstrip()        返回字符串的左修剪版本。
    maketrans()     返回在转换中使用的转换表。
    partition()     返回元组，其中的字符串被分为三部分。
    replace()       返回字符串，其中指定的值被替换为指定的值。
    rfind()         在字符串中搜索指定的值，并返回它被找到的最后位置。
    rindex()        在字符串中搜索指定的值，并返回它被找到的最后位置。
    rjust()         返回字符串的右对齐版本。
    rpartition()    返回元组，其中字符串分为三部分。
    rsplit()        在指定的分隔符处拆分字符串，并返回列表。
    rstrip()        返回字符串的右边修剪版本。
    split()         在指定的分隔符处拆分字符串，并返回列表。
    splitlines()    在换行符处拆分字符串并返回列表。
    startswith()    如果以指定值开头的字符串，则返回 true。
    strip()         返回字符串的剪裁版本。
    swapcase()      切换大小写，小写成为大写，反之亦然。
    title()         把每个单词的首字符转换为大写。
    translate()     返回被转换的字符串。
    upper()         把字符串转换为大写。
    zfill()         在字符串的开头填充指定数量的 0 值。

 四、四种集合数据类型

       列表、元组、集合、字典。

        4.1 列表（List）是一种有序和可更改的集合。允许重复的成员。

1、列表用方括号表示：

list1 = [1, 2, 3, 2]   # 允许重复
list2 = ['ok', 'yes', 'no']


2、使用索引来访问列表项，第一项的索引为 0：

print(list1[2]) #3

也可以使用负索引，表示从尾部向头部编号，-1 表示最后一项，-2 表示倒数第二项，依此类推。

print(list2[-1]) #2

指定索引范围可得到新的列表，格式：列表名[开始索引:结束索引]，注意新列表不包含结束索引处的项。

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

范围也可以使用负索引：

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



3、列表项可更改：

list1[1] = 5
print(list1) #[1, 5, 3, 2]


4、遍历列表项，使用 for in 循环：

for item in list2:
  print(item)


5、测试项目是否存在于列表中，使用 in 和 not in 运算符：

print('yes' in list2)      # True
print('YES' in list2)      # False
print('yes' not in list2)  # False
print('YES' not in list2)  # True


6、求列表长度，使用 len() 函数：

print(len(list1))


7、append(n) 方法向列表末尾追加项 n：

list1.append(5)
print(list1)


8、insert(i, n) 方法向列表指定索引处 i 插入项 n：

list1.insert(2, 9)   # 在索引 2 处插入 9，原来索引 2 处及其后的项后移
print(list1)
list1.insert(-1, 10) # 也可以使用负下标，-1 表示在最末项前插入
print(list1)


9、remove(v) 方法删除列表中的第一个指定项 v：

list1.remove(5)
print(list1)
如果指定项 v 不存在，则运行时报错：
list1.remove(15)  # 不存在 15，报错：ValueError: list.remove(x): x not in list


10、pop(i) 方法删除索引 i 处的项，如果省略 i 则删除最后一项：

list1.pop(1)  # 删除索引 1 处的项
print(list1)
list1.pop()   # 删除最后一项
print(list1)
如果是空表或索引超出范围，则报错：
list1.pop(10)  # 索引 10 超出范围，报错：IndexError: pop index out of range


11、del 关键字（注意不是列表的方法）可以删除指定索引处项：

del list1[0]   # 删除索引 0 处项
print(list1)
也可以删除整个列表：
del list2      # 删除整个表
print(list2)



12、clear() 方法清空（注意不是删除）列表：

list1.clear()      # 清空列表
print(len(list1))  # 长度为 0


13、sort() 方法对列表排序。排序是针对当前列表的，也是稳定的（即等值的项维持其原来的顺序）。

list1 = ['No', 'Abc', 'book', 'abc', 'ABC', 'code', 'Yes']
list1.sort()   # 按列表项的 __lt__() 方法(<)比较的结果升序排序
list1.sort(key = lambda s : s[-1])  # 按列表项的最后元素升序排序
list1.sort(reverse = True)   # 按降序排序
如果列表项的类没有实现 __lt__() 方法，则必须提供 key 参数，否则会报错：
TypeError: '<' not supported between instances of 'xxx' and 'xxx'
key 参数是一个用于返回用作排序的关键字值的函数，这个函数可以是有名或匿名的。用 lambda 表达式
表示的匿名函数更合适。


14、 copy() 方法来复制列表

将一个列表赋值给另一个列表，则它们实际是引用同一个列表，对一个列表更改，另一个也改了：
    list2 = list1   # 赋值使得 list2 引用 list1
    list1.append(1) # 向 list1 追加项
    list1.append(2)
    print(list2)    # list2 也追加了，说明 list2 就是引用的 list1
    print(list1 is list2)  # True，说明 list1 和 list2 实际是同一个列表
但是可以用 copy() 方法来复制列表，新列表与原列表是相互独立的：
    list3 = list1.copy()
    print(list1 is list3)   # False
    list3.append(3) # 向 list3 追加项，不影响 list1，因为它们是不同的列表
    print(list1)
    print(list3)
构造函数 list(o) 也可以复制列表 o 为新列表：
    list4 = list(list1)
    print(list1 is list4)   # False
    list4.append(4) # 向 list4 追加项，不影响 list1，因为它们是不同的列表
    print(list1)
    print(list4)


15、+ 运算符可以合并两个列表为一个新列表：

list1 = [1, 2]
list2 = [3, 4]
list3 = list1 + list2   # 合并为新列表
print(list3)


16、也可以使用 extend(o) 方法将另一个列表 o 添加到列表尾部：

list3.extend(list1)
print(list3)


17、构造函数 list((...)) 可以由一些项来构造新列表：

list4 = list((1, 2, 3))  # 注意使用双括号 (())，列表使用 () 括住
print(list4)

构造函数 list([...]) 可以由一些项来构造新列表：

list5 = list([4, 5, 6])  # 列表使用方括号 []
print(list5)

不使用 () 或 [] 则报错：TypeError: list expected at most 1 argument, got 3

list6 = list(4, 5, 6)  # list 最多只接受一个参数，而这里有 3 个

同一列表中的项的类型并不要求必须相同：

list1.append('one')  # 追加字符串
list1.append(2.5)    # 追加小数
list1.append(list2)  # 追加另一个列表，注意是将整个 list2 列表作为 list1 的一项追加
list1.append(1 + 2j) # 追加复数
print(list1)   # [1, 2, 'one', 2.5, [3, 4], (1+2j)]

列表可以与一个整数 n 相乘，生成 n 倍长的新列表：

list1 = [1, "two", 3.5]
list2 = list1 * 2
print(list2)

如果乘以小于或等于 0 的整数，则生成空列表：

list3 = list1 * 0
list4 = list2 * -1
print(len(list3))  # 0
print(len(list4))  # 0

18、列表的内建方法：
--------------------------------------------------------------------
方法        描述
--------------------------------------------------------------------
append()    在列表的末尾添加一个元素
clear()     删除列表中的所有元素
copy()      返回列表的副本
count()     返回具有指定值的元素数量。
extend()    将列表元素（或任何可迭代的元素）添加到当前列表的末尾
index()     返回具有指定值的第一个元素的索引
insert()    在指定位置添加元素
pop()       删除指定位置的元素
remove()    删除具有指定值的项目
reverse()   颠倒列表的顺序
sort()      对列表进行排序
--------------------------------------------------------------------

        4.2 元组（Tuple）是一种有序且不可更改的集合。允许重复的成员。

        4.3 集合（Set）是一个无序和无索引的集合。没有重复的成员。

        4.4 字典（Dictionary）是一个无序，可变和有索引的集合。没有重复的成员。