SPSS提示“列表中不允许存在字符串变量”的解决方法
参考文章：
（2）https://www.cnblogs.com/kjkj/p/10484589.html
备忘一下。
今天用SPSS对一些数据进行主成分分析，SPSS 19.0进行主成分分析的方法是：分析——降维——因子分析，可是当导入一些变量的时候。就会弹出窗体说“列表中不同意存在字符串变量”，能够点击：视图——变量，看到各个变量的类型，发现确实有些变量是字符串类型的。我的数据是以csv格式保存的，但SPSS在导入的时候就可能出现故障。假设直接在“变量”这一界面下改动类型。将会导致变量的值发生变化（比如我这里从小数变成了全是0和1）
正确的处理方法也非常easy。将csv用Excel打开，然后另存为xls格式，再用SPSS导入就能够了。
2017年2月19日更新：
这个日志写了非常久，认为自己之前的方法太笨了。并且有可能会有问题，介绍一下为什么直接改动类型会使数值变化的原因：由于在改动变量类型的时候。假设数据有小数，须要选择小数的位数。就在前面说的“变量”界面下，点击类型旁边的省略号。选择成“数值”。然后指定小数位为非0的数字就可以。
Python基础入门知识点总结传送门
第一章 认识Python、Python常用集成开发环境PyCharm
第二章 注释、变量基本使用、变量的命名
第三章 运算符、判断if语句、while和for循环
第四章 列表、元组、字典、字符串变量使用、变量进阶
第五章 函数基础、函数进阶
第六章 面向对象基础
第七章 面向对象三大特性、单例设计模式
第八章 文件读写操作、模块和包、异常
一、高级变量类型
Python 中数据类型可以分为 数字型 和 非数字型
数字型
int)float）bool）
True 非 0 数 —— 非零即真False 0complex)
非数字型
在 Python 中，所有 非数字型变量 都支持以下特点：
sequence，也可以理解为 容器[]for in+ 和 重复 *List（列表） 是 Python 中使用 最频繁 的数据类型，在其他语言中通常叫做 数组[] 定义，数据 之间使用 , 分隔0 开始
注意：从列表中取值时，如果 超出索引范围，程序会报错
name_list = ["zhangsan", "lisi", "wangwu"]
增加、删除、修改、查询| 序号 | 分类 | 关键字 / 函数 / 方法 | 说明 |
|---|---|---|---|
| 1 | 增加 | 列表.insert(索引, 数据) | 在指定位置插入数据 |
| 列表.append(数据) | 在末尾追加数据 | ||
| 列表.extend(列表2) | 将列表2 的数据追加到列表 | ||
| 2 | 修改 | 列表[索引] = 数据 | 修改指定索引的数据 |
| 3 | 删除 | del 列表[索引] | 删除指定索引的数据 |
| 列表.remove[数据] | 删除第一个出现的指定数据 | ||
| 列表.pop | 删除末尾数据(返回值是删除的数据) | ||
| 列表.pop(索引) | 删除指定索引数据 (返回值是删除的数据) | ||
| 列表.clear | 清空列表 | ||
| 4 | 统计 | len(列表) | 列表长度 |
| 列表.count(数据) | 数据在列表中出现的次数 | ||
| 5 | 排序 | 列表.sort() | 升序排序 |
| 列表.sort(reverse=True) | 降序排序 | ||
| 列表.reverse() | 逆序、反转 |
del 关键字(delete) 同样可以删除列表中元素del 关键字本质上是用来 将一个变量从内存中删除的del 关键字将变量从内存中删除，后续的代码就不能再使用这个变量了del name_list[1]
在日常开发中，要从列表删除数据，建议 使用列表提供的方法
遍历 就是 从头到尾 依次 从 列表 中获取数据
在 Python 中为了提高列表的遍历效率，专门提供的 迭代 iteration 遍历
使用 for 就能够实现迭代遍历
# for 循环内部使用的变量 in 列表
for name in name_list:
循环内部针对列表元素进行操作
print(name)
Python 的 列表 中可以 存储不同类型的数据在 Python 中，因为元组是不可变的，元素不能修改
Tuple（元组）与列表类似，不同之处在于元组的 元素不能修改
Python 开发中，有特定的应用场景, 分隔() 定义0 开始
info_tuple = ("zhangsan", 18, 1.75)
info_tuple = ()
info_tuple = (50, )
# for 循环内部使用的变量 in 元组
for item in info:
循环内部针对元组元素进行操作
print(item)
- 在
Python中，可以使用for循环遍历所有非数字型类型的变量：列表、元组、字典 以及 字符串- 提示：在实际开发中，除非 能够确认元组中的数据类型，否则针对元组的循环遍历需求并不是很多
for in 遍历 元组() 本质上就是一个元组info = ("zhangsan", 18)
print("%s 的年龄是 %d" % info)
list 函数可以把元组转换成列表list(元组)
tuple 函数可以把列表转换成元组tuple(列表)
dictionary（字典） 是 除列表以外 Python 之中 最灵活 的数据类型物体 的相关信息{} 定义, 分隔
key 是索引value 是数据: 分隔xiaoming = {"name": "小明",
"age": 18,
"gender": True,
"height": 1.75}
# for 循环内部使用的 `key 的变量` in 字典
for k in xiaoming:
print("%s: %s" % (k, xiaoming[k]))
提示：在实际开发中，由于字典中每一个键值对保存数据的类型是不同的，所以针对字典的循环遍历需求并不是很多
for in 遍历 字典物体 的相关信息 —— 描述更复杂的数据信息card_list = [{"name": "张三",
"qq": "12345",
"phone": "110"},
{"name": "李四",
"qq": "54321",
"phone": "10086"}
]
" 或者 一对单引号 ' 定义一个字符串
\" 或者 \' 做字符串的转义，但是在实际开发中：
"，可以使用 ' 定义字符串'，可以使用 " 定义字符串for 循环遍历 字符串中每一个字符大多数编程语言都是用
"来定义字符串
string = "Hello Python"
for c in string:
print(c)
| 方法 | 说明 |
|---|---|
| string.isspace() | 如果 string 中只包含空格，则返回 True |
| string.isalnum() | 如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True |
| string.isalpha() | 如果 string 至少有一个字符并且所有字符都是字母则返回 True |
| string.isdecimal() | 如果 string 只包含数字则返回 True，全角数字 |
| string.isdigit() | 如果 string 只包含数字则返回 True，全角数字、⑴、\u00b2 |
| string.isnumeric() | 如果 string 只包含数字则返回 True，全角数字，汉字数字 |
| string.istitle() | 如果 string 是标题化的(每个单词的首字母大写)则返回 True |
| string.islower() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True |
| string.isupper() | 如果 string 中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True |
| 方法 | 说明 |
|---|---|
| string.startswith(str) | 检查字符串是否是以 str 开头，是则返回 True |
| string.endswith(str) | 检查字符串是否是以 str 结束，是则返回 True |
| string.find(str, start=0, end=len(string)) | 检测 str 是否包含在 string 中，如果 start 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回 -1 |
| string.rfind(str, start=0, end=len(string)) | 类似于 find()，不过是从右边开始查找 |
| string.index(str, start=0, end=len(string)) | 跟 find() 方法类似，不过如果 str 不在 string 会报错 |
| string.rindex(str, start=0, end=len(string)) | 类似于 index()，不过是从右边开始 |
| string.replace(old_str, new_str, num=string.count(old)) | 把 string 中的 old_str 替换成 new_str，如果 num 指定，则替换不超过 num 次 |
| 方法 | 说明 |
|---|---|
| string.capitalize() | 把字符串的第一个字符大写 |
| string.title() | 把字符串的每个单词首字母大写 |
| string.lower() | 转换 string 中所有大写字符为小写 |
| string.upper() | 转换 string 中的小写字母为大写 |
| string.swapcase() | 翻转 string 中的大小写 |
| 方法 | 说明 |
|---|---|
| string.ljust(width) | 返回一个原字符串左对齐，并使用空格填充至长度 width 的新字符串 |
| string.rjust(width) | 返回一个原字符串右对齐，并使用空格填充至长度 width 的新字符串 |
| string.center(width) | 返回一个原字符串居中，并使用空格填充至长度 width 的新字符串 |
| 方法 | 说明 |
|---|---|
| string.lstrip() | 截掉 string 左边（开始）的空白字符 |
| string.rstrip() | 截掉 string 右边（末尾）的空白字符 |
| string.strip() | 截掉 string 左右两边的空白字符 |
| 方法 | 说明 |
|---|---|
| string.partition(str) | 把字符串 string 分成一个 3 元素的元组 (str前面, str, str后面) |
| string.rpartition(str) | 类似于 partition() 方法，不过是从右边开始查找 |
| string.split(str="", num) | 以 str 为分隔符拆分 string，如果 num 有指定值，则仅分隔 num + 1 个子字符串，str 默认包含 ‘\r’, ‘\t’, ‘\n’ 和空格 |
| string.splitlines() | 按照行(’\r’, ‘\n’, ‘\r\n’)分隔，返回一个包含各行作为元素的列表 |
| string.join(seq) | 以 string 作为分隔符，将 seq 中所有的元素（的字符串表示）合并为一个新的字符串 |
字符串[开始索引:结束索引:步长]
注意：
[开始索引, 结束索引) => 开始索引 >= 范围 < 结束索引
起始 位开始，到 结束位的前一位 结束（不包含结束位本身)1，如果连续切片，数字和冒号都可以省略演练需求
末尾 的字符串开始 ~ 5 位置 的字符串末尾 - 1 的字符串答案
num_str = "0123456789"
# 1. 截取从 2 ~ 5 位置 的字符串
print(num_str[2:6])
# 2. 截取从 2 ~ `末尾` 的字符串
print(num_str[2:])
# 3. 截取从 `开始` ~ 5 位置 的字符串
print(num_str[:6])
# 4. 截取完整的字符串
print(num_str[:])
# 5. 从开始位置，每隔一个字符截取字符串
print(num_str[::2])
# 6. 从索引 1 开始，每隔一个取一个
print(num_str[1::2])
# 倒序切片
# -1 表示倒数第一个字符
print(num_str[-1])
# 7. 截取从 2 ~ `末尾 - 1` 的字符串
print(num_str[2:-1])
# 8. 截取字符串末尾两个字符
print(num_str[-2:])
# 9. 字符串的逆序（面试题）
print(num_str[::-1])
Python 包含了以下内置函数：
| 函数 | 描述 | 备注 |
|---|---|---|
| len(item) | 计算容器中元素个数 | |
| del(item) | 删除变量 | del 有两种方式 |
| max(item) | 返回容器中元素最大值 | 如果是字典，只针对 key 比较 |
| min(item) | 返回容器中元素最小值 | 如果是字典，只针对 key 比较 |
注意
| 运算符 | Python 表达式 | 结果 | 描述 | 支持的数据类型 |
|---|---|---|---|---|
| + | [1, 2] + [3, 4] | [1, 2, 3, 4] | 合并 | 字符串、列表、元组 |
| * | [“Hi!”] * 4 | [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] | 重复 | 字符串、列表、元组 |
| in | 3 in (1, 2, 3) | True | 元素是否存在 | 字符串、列表、元组、字典 |
| not in | 4 not in (1, 2, 3) | True | 元素是否不存在 | 字符串、列表、元组、字典 |
| > >= == < <= | (1, 2, 3) < (2, 2, 3) | True | 元素比较 | 字符串、列表、元组 |
注意
in 在对 字典 操作时，判断的是 字典的键in 和 not in 被称为 成员运算符成员运算符用于 测试 序列中是否包含指定的 成员
| 运算符 | 描述 | 实例 |
|---|---|---|
| in | 如果在指定的序列中找到值返回 True，否则返回 False | 3 in (1, 2, 3) 返回 True |
| not in | 如果在指定的序列中没有找到值返回 True，否则返回 False | 3 not in (1, 2, 3) 返回 False |
注意：在对 字典 操作时，判断的是 字典的键
Python 中完整的 for 循环 的语法如下：for 变量 in 集合:
循环体代码
else:
没有通过 break 退出循环，循环结束后，会执行的代码
students = [
{"name": "阿土",
"age": 20,
"gender": True,
"height": 1.7,
"weight": 75.0},
{"name": "小美",
"age": 19,
"gender": False,
"height": 1.6,
"weight": 45.0},
]
find_name = "阿土"
for stu_dict in students:
print(stu_dict)
# 判断当前遍历的字典中姓名是否为find_name
if stu_dict["name"] == find_name:
print("找到了")
# 如果已经找到，直接退出循环，就不需要再对后续的数据进行比较
break
else:
print("没有找到")
print("循环结束")
- 变量 和 数据 都是保存在 内存 中的
- 在
Python中 函数 的 参数传递 以及 返回值 都是靠 引用 传递的
在 Python 中
id() 函数可以查看变量中保存数据所在的 内存地址注意：如果变量已经被定义，当给一个变量赋值的时候，本质上是 修改了数据的引用
- 变量 不再 对之前的数据引用
- 变量 改为 对新赋值的数据引用
在 Python 中，函数的 实参/返回值 都是是靠 引用 来传递来的
def test(num):
print("-" * 50)
print("%d 在函数内的内存地址是 %x" % (num, id(num)))
result = 100
print("返回值 %d 在内存中的地址是 %x" % (result, id(result)))
print("-" * 50)
return result
a = 10
print("调用函数前 内存地址是 %x" % id(a))
r = test(a)
print("调用函数后 实参内存地址是 %x" % id(a))
print("调用函数后 返回值内存地址是 %x" % id(r))
不可变类型，内存中的数据不允许被修改：
int, bool, float, complex, long(2.x)strtuple可变类型，内存中的数据可以被修改：
listdicta = 1
a = "hello"
a = [1, 2, 3]
a = [3, 2, 1]
demo_list = [1, 2, 3]
print("定义列表后的内存地址 %d" % id(demo_list))
demo_list.append(999)
demo_list.pop(0)
demo_list.remove(2)
demo_list[0] = 10
print("修改数据后的内存地址 %d" % id(demo_list))
demo_dict = {"name": "小明"}
print("定义字典后的内存地址 %d" % id(demo_dict))
demo_dict["age"] = 18
demo_dict.pop("name")
demo_dict["name"] = "老王"
print("修改数据后的内存地址 %d" % id(demo_dict))
注意：字典的
key只能使用不可变类型的数据
注意
(hash)Python 中内置有一个名字叫做 hash(o) 的函数
哈希 是一种 算法，其作用就是提取数据的 特征码（指纹）
Python 中，设置字典的 键值对 时，会首先对 key 进行 hash 已决定如何在内存中保存字典的数据，以方便 后续 对字典的操作：增、删、改、查
key 必须是不可变类型数据value 可以是任意类型的数据提示：在其他的开发语言中，大多 不推荐使用全局变量 —— 可变范围太大，导致程序不好维护！
def demo1():
num = 10
print(num)
num = 20
print("修改后 %d" % num)
def demo2():
num = 100
print(num)
demo1()
demo2()
print("over")
# 定义一个全局变量
num = 10
def demo1():
print(num)
def demo2():
print(num)
demo1()
demo2()
print("over")
注意：函数执行时，需要处理变量时 会：
全局变量的引用提示：在其他的开发语言中，大多 不推荐使用全局变量 —— 可变范围太大，导致程序不好维护！
num = 10
def demo1():
print("demo1" + "-" * 50)
# 只是定义了一个局部变量，不会修改到全局变量，只是变量名相同而已
num = 100
print(num)
def demo2():
print("demo2" + "-" * 50)
print(num)
demo1()
demo2()
print("over")
注意：只是在函数内部定义了一个局部变量而已，只是变量名相同 —— 在函数内部不能直接修改全局变量的值
global 进行声明num = 10
def demo1():
print("demo1" + "-" * 50)
# global 关键字，告诉 Python 解释器 num 是一个全局变量
global num
# 只是定义了一个局部变量，不会修改到全局变量，只是变量名相同而已
num = 100
print(num)
def demo2():
print("demo2" + "-" * 50)
print(num)
demo1()
demo2()
print("over")
a = 10
def demo():
print("%d" % a)
print("%d" % b)
print("%d" % c)
b = 20
demo()
c = 30
注意
g_ 或者 gl_ 的前缀创作不易，白嫖不好，各位的支持和认可，就是我创作的最大动力，我们下篇文章见！
Dragon少年 | 文
如果本篇博客有任何错误，请批评指教，不胜感激 ！
现在要查，sex为男，age为20的那些数据，可用如下语句：
select*fromstudentwheresex='男'andage=20;
SELECT * FROM Persons WHERE City='Beijing'
SELECT * FROM Persons WHERE Year>1965递增：
SELECT Company, OrderNumber FROM OrdersORDER BY Company, OrderNumber
递减：
SELECT Company, OrderNumber FROM OrdersORDER BY Company DESC
//字符串型：
stringa ="90";
stringsql ="select * from biao where o='"+ a +"'";
//数字型
inti = 10;
sql ="select * from biao where o="+ i +"";一、排序检索数据
1.排序数据：SELECT prod_name FROM Products ORDER BY prod_name（对prod_name列以字母顺序排序数据）
ORDER BY子句的位置
在指定一条ORDER BY子句时，应该保证它是SELECT语句中最后一条子句。如果它不是最后的子句，将会出现错误消息。
通过非选择列进行排序
通常，ORDER BY子句中使用的列将是为显示而选择的列。但是，实际上并不一定要这样，用非检索的列排序数据是完全合法的。2.按多个列排序：SELECT prod_id,prod_price,prod_name FROM Products ORDER BY prod_price,prod_name
重要的是理解在按多个列排序时，排序的顺序完全按规定进行。换句话说，对于上述例子中的输出，仅在多个行具有相同的prod_price值时才对产品按prod_name进行排序。如果prod_price列中所有的值都是唯一的，则不会按prod_name排序。
3.按列位置排序：SELECT prod_id,prod_price,prod_name FROM Products ORDER BY 2,3 这个和按多个列排序结果是一样的，无非就是本来的列名称改成了位置序号。
可以看到，这里的输出与上面的查询相同，不同之处在于ORDER BY子句。SELECT清单中指定的是选择列的相对位置而不是列名。ORDER BY 2表示按SELECT清单中的第二个列prod_name进行排序。ORDER BY 2，3表示先按prod_price，再按prod_name进行排序。
这一技术的主要好处在于不用重新输入列名。但它也有缺点。首先，不明确给出列名有可能造成错用列名排序。其次，在对SELECT清单进行更改时容易错误地对数据进行排序（忘记对ORDER BY子句做相应的改动）。最后，如果进行排序的列不在SELECT清单中，显然不能使用这项技术。4.指定排序方向：SELECT prod_id,prod_price,prod_name FROM Products ORDER BY prod_price DESC
SELECT prod_id,prod_price,prod_name FROM Products ORDER BY prod_price DESC,prod_name
DESC关键字只应用到直接位于其前面的列名。在上例中，只对prod_price列指定DESC，对prod_name列不指定。因此，prod_price列以降序排序，而prod_name列（在每个价格内）仍然按标准的升序排序。
警告：在多个列上降序排序
如果想在多个列上进行降序排序，必须对每一列指定DESC关键字。
请注意，DESC是DESCENDING的缩写，这两个关键字都可以使用。与DESC相对的是ASC（或ASCENDING），在升序排序时可以指定它。但实际上，ASC没有多大用处，因为升序是默认的（如果既不指定ASC也不指定DESC，则假定为ASC）。
提示：区分大小写和排序顺序
在对文本性数据进行排序时，A与a相同吗？a位于B之前，还是Z之后？这些问题不是理论问题，其答案取决于数据库的设置方式。
在字典（dictionary）排序顺序中，A被视为与a相同，这是大多数数据库管理系统的默认行为。但是，许多DBMS允许数据库管理员在需要时改变这种行为（如果你的数据库包含大量外语字符，可能必须这样做）。
这里的关键问题是，如果确实需要改变这种排序顺序，用简单的ORDER BY子句可能做不到。你必须请求数据库管理员的帮助。二、过滤数据
1.where语句：SELECT prod_name,prod_price FROM Products WHERE prod_price=3.49
警告：WHERE子句的位置
在同时使用ORDER BY和WHERE子句时，应该让ORDER BY位于WHERE之后，否则将会产生错误。例如：SELECT prod_name,prod_price FROM Products WHERE prod_price=3.49 ORDER BY prod_name ASC
2.检查单个值：SELECT prod_name,prod_price FROM Products WHERE prod_price < 0
3.不匹配检查：SELECT vend_id,prod_name FROM Products WHERE vend_id <>'DLL01'
4.范围值检查：SELECT prod_name,prod_price FROM Products WHERE prod_price BETWEEN 5 AND 10
5.空值检查： SELECT cust_name FROM customers WHERE cust_email IS NULL
三、高级数据过滤
1.AND操作符：SELECT prod_id,prod_price,prod_name FROM Products WHERE vend_id='DLL01' AND prod_price <=4
此SQL语句检索由供应商DLL01制造且价格小于等于4美元的所有产品的名称和价格。这条SELECT语句中的WHERE子句包含两个条件，用AND关键字联结在一起。AND指示DBMS只返回满足所有给定条件的行。如果某个产品由供应商DLL01制造，但价格高于4美元，则不检索它。
AND
用在WHERE子句中的关键字，用来指示检索满足所有给定条件的行。
这个例子只包含一个AND子句，因此最多有两个过滤条件。可以增加多个过滤条件，每个条件间都要使用AND关键字。
说明：没有ORDER BY子句
为了节省空间，也为了减少你的输入，我在很多例子里省略了ORDER BY子句。因此，你的输出完全有可能与书上的输出不一致。虽然返回行的数量总是对的，但它们的顺序可能不同。当然，如果你愿意也可以加上一个ORDER BY子句，它应该放在WHERE子句之后。
2.OR操作符：SELECT vend_id,prod_price,prod_name FROM Products WHERE vend_id='DLL01' OR vend_id='BRS01'此SQL语句检索由任一个指定供应商制造的所有产品的产品名和价格。OR操作符告诉DBMS匹配任一条件而不是同时匹配两个条件。
3.求值顺序（AND OR）
输入：
SELECT prod_name, prod_price FROM Products
WHERE vend_id = 'DLL01' OR vend_id = 'BRS01' AND prod_price >= 10
输出：
问题：请看上面的结果。返回的行中有4行价格小于10美元，显然，返回的行未按预期的进行过滤。为什么会这样呢？原因在于求值的顺序。SQL（像多数语言一样）在处理OR操作符前，优先处理AND操作符。当SQL看到上述WHERE子句时，它理解为：由供应商BRS01制造的价格为10美元以上的所有产品，以及由供应商DLL01制造的所有产品，而不管其价格如何。换句话说，由于AND在求值过程中优先级更高，操作符被错误地组合了。
解决方法：
SELECT prod_name, prod_price FROM Products
WHERE (vend_id = 'DLL01' OR vend_id = 'BRS01') AND prod_price >= 10
其实只要用括号括起来就好了
提示：在WHERE子句中使用圆括号
任何时候使用具有AND和OR操作符的WHERE子句，都应该使用圆括号明确地分组操作符。不要过分依赖默认求值顺序，即使它确实如你希望的那样。使用圆括号没有什么坏处，它能消除歧义。4.IN操作符
输入：
SELECT vend_id,prod_name,prod_price FROM Products
WHERE vend_id IN ('DLL01','BRS01')
ORDER BY prod_name输出：
为什么要使用IN操作符？其优点为：
IN
WHERE子句中用来指定要匹配值的清单的关键字，功能与OR相当。
5.NOT操作符
SELECT prod_name FROM Products
WHERE NOT vend_id = 'DLL01'
ORDER BY prod_name;
为什么使用NOT？对于这里的这种简单的WHERE子句，使用NOT确实没有什么优势。但在更复杂的子句中，NOT是非常有用的。例如，在与IN操作符联合使用时，NOT可以非常简单地找出与条件列表不匹配的行。
